TODO: this method could move to a more general place.
344849
private static Adapter tryAdapter( Class adapterClass, Object externalContext )
    {
        try
        {
            Adapter sa = ( Adapter ) adapterClass.newInstance();

            try
            {
                AdapterContext context = new AdapterContext( externalContext );
                
                if ( sa.accept( context ) )
                {
                    _log.info( "Adapter " + adapterClass.getName() + " accepted." );
                    sa.setContext( context );
                    return sa;
                }
                else
                {
                    _log.info( "Adapter " + adapterClass.getName() + " is present but did not accept." );
                }
            }
            catch ( Exception e )
            {
                _log.error( adapterClass.getName() + ".accept() threw an exception.", e );
            }
            catch ( LinkageError e )
            {
                _log.error( adapterClass.getName() + ".accept() caused a linkage error and may be out of date.", e );
            }
        }
        catch ( InstantiationException e )
        {
            _log.error( "Could not create instance of Adapter class " + adapterClass.getName(), e );
        }
        catch ( IllegalAccessException e )
        {
            _log.error( "Could not create instance of Adapter class " + adapterClass.getName(), e );
        }
        catch ( Exception e )
        {
            _log.error( "Error creating instance of Adapter class " + adapterClass.getName(), e );
        }

        return null;
    }
365268
def move_up(self):
        
        old_index = self.current_index
        self.current_index -= 1
        self.__wrap_index()
        self.__handle_selections(old_index, self.current_index)
725632
public void go() {
		long nextPriority = Long.MIN_VALUE;
		for (Long d : handlers.getPriorities()) {
			if (nextPriority > d) continue;
			AnnotationVisitor visitor = new AnnotationVisitor(d);
			ast.traverse(visitor);
			// if no visitor interested for this AST, nextPriority would be MAX_VALUE and we bail out immediatetly
			nextPriority = visitor.getNextPriority();
			nextPriority = Math.min(nextPriority, handlers.callASTVisitors(ast, d, ast.isCompleteParse()));
		}
	}
83914
public void moveTo (ClientObject caller, int placeOid, LocationService.MoveListener listener)
        throws InvocationException
    {
        // do the move and send the response
        BodyObject body = _locator.forClient(caller);
        listener.moveSucceeded(moveTo(body, placeOid));
    }
357105
@Override
	public void relocate()
	{

		int w = 360, h = 245;

		int x = (this.getWidth() - w) / 2;
		int y = (this.getHeight() - h) / 2;

		outputLabel.setLocation(x, y);
		outputPathField.setLocation(x + 160, y);

		enableZipEncodingCompression.setLocation(x + 110, y + 40);
		outputCompression.setLocation(x + 110, y + 75);
		disableOutputCompression.setLocation(x + 110, y + 100);
		enableBZip2OutputCompression.setLocation(x + 110, y + 120);
		enable7ZipOutputCompression.setLocation(x + 110, y + 140);
		activateDataFileOutput.setLocation(x + 110, y + 160);

		enableMultipleOutputFiles.setLocation(x, y + 190);
		outputSizeLimitLabel.setLocation(x, y + 220);
		outputSizeLimitField.setLocation(x + 160, y + 220);

	}
1242690
private void moveToTop(List<String> keys, String propertyName) {

        if (keys.contains(propertyName)) {
            keys.remove(propertyName);
            keys.add(0, propertyName);
        }
    }
1268604
function Place (opts) {
    Place.superclass.constructor.call(this, opts)
    this.position = util.copy(opts.position)
}
16797
def move(self, d_xyz):
        
        return Space(Place(self)).move(d_xyz, inplace=False)[0].surface
782115
private void advance() {
        next = null;
        while (next == null) {
            // If 
            if (ext != null) {
                next = ext.next();
                if (next != null)
                    return;
            }
            if (!vertexIter.hasNext())
                return;

            // Otherwise the extension is null or there are no more remaining
            // subgraphs in it, so create a new 
            int nextVertex = vertexIter.nextInt();
            veryVerbose(LOGGER, "Loading next round of subgraphs starting " +
                        "from vertex %d", nextVertex);
            ext = new Extension(nextVertex);
        }
    }
191444
private void expand()
    {
        int i;
        if (isCompact) {
            byte[]  tempArray;
            hashes = new int[INDEXCOUNT];
            tempArray = new byte[UNICODECOUNT];
            for (i = 0; i < UNICODECOUNT; ++i) {
                byte value = elementAt((char)i);
                tempArray[i] = value;
                touchBlock(i >> BLOCKSHIFT, value);
            }
            for (i = 0; i < INDEXCOUNT; ++i) {
                indices[i] = (char)(i<<BLOCKSHIFT);
            }
            values = null;
            values = tempArray;
            isCompact = false;
        }
    }
91377
def relocate(self):
        """"""

        name = self.SearchVar.get()
        if self.kbos.has_key(name):
            kbo = self.kbos[name]
            assert isinstance(kbo, orbfit.Orbfit)
            this_time = Time(self.date.get(), scale='utc')
            try:
                kbo.predict(this_time)
                self.recenter(kbo.coordinate.ra.radian, kbo.coordinate.dec.radian)
                self.create_point(kbo.coordinate.ra.radian, kbo.coordinate.dec.radian, color='blue', size=4)
            except:
                logging.error("failed to compute KBO position")
804990
public <T> void move(Local<T> target, Local<T> source) {
        addInstruction(new PlainInsn(Rops.opMove(source.type.ropType),
                sourcePosition, target.spec(), source.spec()));
    }
230883
function move(x, y) {
         this.moveTo(this.pos.x + x, this.pos.y + y);
       }
602674
function extend(destination, source) {
    for (var k in source) {
      if (source.hasOwnProperty(k)) {
        destination[k] = source[k];
      }
    }
    return destination;
  }
1004930
public void push(E d) {
        StackNode<E> oldTop, newTop;

        newTop = new StackNode<E>(d);

        while (true) {
            oldTop = top.get();
            newTop.next = oldTop;
            if (oldTop != null)
                newTop.index = oldTop.index + 1;
            else
                newTop.index = 0;
            if (top.compareAndSet(oldTop, newTop))
                return;
        }
    }
1362977
private void move1() {
        if (node == null)
            return;

        if (position >= reference.size()) {
            node = null;
            return;
        }

        node = node.links[reference.codeAt(position++)];
    }
796255
private void moveToPrevious() {
        if (controller != null) {
            currentItemIndex = controller.previousItem(this, currentItemIndex);
        } else {
            currentItemIndex = defaultController.previousItem(this, currentItemIndex);
        }
    }