protected AbstractClass addInnerClasses(Iterable<IsClass> clses) { for (IsClass cls : clses) { innerClasses.give(cls); } return this; }
@Override public Iterable<IsClass> getInnerClasses() { return innerClasses.forEach(); }
@Override public boolean hasInterface() { return !interfaces.isEmpty(); }
/** * Adds a receiver to the end of the callback array. * * @param receiver - A new receiver to add * @return true if the receiver was added to our callbacks; false if already present. */ public boolean addReceiver(ReceivesValue<T> receiver){ assert receiver != null : "Do not send null receivers to "+this+"; (ReceivesMultiValue) "; assert receiver != this : "Do not send a ReceivesMultiValue to itself. Class: "+this+";"; if (handlers.contains(receiver)) return false; handlers.give(receiver); return true; }
if (fifo == null) { fifo = new SimpleFifo<String>(); fifo.give(pkg); classPaths.put(resource, fifo); } else { fifo.remove(pkg); fifo.give(pkg); for (URL url : classPaths.keySet()) { Fifo<String> packages = classPaths.get(url); jobs.give(executor.submit(newScanRunner(url, map, executor, packages.forEach(), pos))); while (!jobs.isEmpty()) { Iterator<Future<?>> iter = jobs.forEach().iterator(); while (iter.hasNext()) { if (iter.next().isDone()) iter.remove();
public Iterable<ModelField> getAllSerializable() { final Fifo<ModelField> fifo = X_Collect.newFifo(); for (final ModelField field : fields.values()) { final Serializable serial = field.getSerializable(); if (serial == null) { final ClientToServer c2s = field.getClientToServer(); if (c2s != null && c2s.enabled()) { fifo.give(field); continue; } final ServerToClient s2c = field.getServerToClient(); if (s2c != null && s2c.enabled()) { fifo.give(field); continue; } } else { // class is marked serializable fifo.give(field); } } return fifo.forEach(); }
ctorParams.give(param); if (dflt == null) { requiredFields.give(param); if (requiredFields.size() == 0) { final SimpleFifo<String> joinable = new SimpleFifo<String>(); final MethodBuffer ctor = annoBuilder.createMethod("private " + builderName + "(" + requiredFields.join(", ") + ")"); for (String field : requiredFields.forEach()) { field = field.substring(field.lastIndexOf(' ') + 1); joinable.give(field); + requiredFields.join(", ") + ")").returnValue( "new " + builderName + "(" + joinable.join(", ") + ")"); if (ctorParams.size() > 0) { final MethodBuffer ctor = immutableAnno.createMethod("private " + immutableAnno.getSimpleName() + "()"); + " build()"); final SimpleFifo<String> fieldRefs = new SimpleFifo<String>(); for (final String param : ctorParams.forEach()) { final int end = param.lastIndexOf(' '); ctor.addParameters(param);
/** * Clear our array of callbacks */ public void clearReceivers(){ handlers.clear(); } /**
/** * @param receiver - The receiver to remove. */ public void removeReceiver(ReceivesValue<T> receiver){ handlers.remove(receiver); }
@Override public void set(X value) { ProvidesValue<ReceivesValue<X>> local; while((local=providers.take())!=null){ local.get().set(value); } local = null; } };
@Override public String toSignature() { return X_Modifier.classModifiers(getModifier()) + (hasInterface() ? " interface " : " class ") + (hasGenerics() ? "<"+ generics.join(", ") + ">" : "") + (parentClass == null ? ( // no superclass, maybe print interface extends hasInterface() ? "\nextends " + interfaces.join(", ") : "" ) : // we have a superclass "\nextends "+parentClass.getEnclosedName() + (// do we have interfaces? hasInterface() ? "\nimplements "+interfaces.join(", ") : "" ) ) // end parentClass == null ? ; }
public final void add(ProvidesValue<ReceivesValue<X>> provider){ assert !providers.contains(provider) : new RuntimeException("You have sent the same provider instance to a DeferredMultiReceiver more than once: "+provider); providers.give(provider); } public final void add(final ReceivesValue<X> provider){
/** * Adds a callback that will be fired before the main and post callback stacks * * @param receiver - The receiver to add to pre-fire stack * @param top - true to unshift onto head, false to push onto tail */ public void addPre(ReceivesValue<T> receiver){ assert receiver != null : "Do not send null receivers to "+this+"; (ReceivesMultiValue.addBefore) "; assert receiver != this : "Do not send a ReceivesMultiValue to itself. Class: "+this+";"; pre.give(receiver); } /**