@Nullable
private static RunContentDescriptor chooseReuseContentForDescriptor(
final ContentManager contentManager, final RunContentDescriptor descriptor) {
Content content = null;
if (descriptor != null) {
if (descriptor.isContentReuseProhibited()) {
return null;
}
final Content attachedContent = descriptor.getAttachedContent();
if (attachedContent != null && attachedContent.isValid()) content = attachedContent;
}
if (content == null) {
content = contentManager.getSelectedContent();
if (content != null && content.isPinned()) content = null;
}
if (content == null || !isTerminated(content)) {
return null;
}
final RunContentDescriptor oldDescriptor = getRunContentDescriptorByContent(content);
if (oldDescriptor != null && !oldDescriptor.isContentReuseProhibited()) {
return oldDescriptor;
}
return null;
}
@Override
public boolean serialize(final ByteBuffer buffer) {
if (this.contents.size() > 65535) {
return false;
}
buffer.putShort((short) this.contents.size());
for (int i = 0; i < this.contents.size(); ++i) {
final Content contents_element = this.contents.get(i);
final boolean contents_element_ok = contents_element.serialize(buffer);
if (!contents_element_ok) {
return false;
}
}
if (this.contentsSelection != null) {
buffer.put((byte) 1);
final boolean contentsSelection_ok = this.contentsSelection.serialize(buffer);
if (!contentsSelection_ok) {
return false;
}
} else {
buffer.put((byte) 0);
}
if (this.buyableContents.size() > 65535) {
return false;
}
buffer.putShort((short) this.buyableContents.size());
for (int i = 0; i < this.buyableContents.size(); ++i) {
final BuyableContent buyableContents_element = this.buyableContents.get(i);
final boolean buyableContents_element_ok = buyableContents_element.serialize(buffer);
if (!buyableContents_element_ok) {
return false;
}
}
return true;
}
public final void internalToString(final StringBuilder repr, final String prefix) {
repr.append(prefix).append("contents=");
if (this.contents.isEmpty()) {
repr.append("{}").append('\n');
} else {
repr.append("(").append(this.contents.size()).append(" elements)...\n");
for (int i = 0; i < this.contents.size(); ++i) {
final Content contents_element = this.contents.get(i);
contents_element.internalToString(repr, prefix + i + "/ ");
}
}
repr.append(prefix).append("contentsSelection=");
if (this.contentsSelection == null) {
repr.append("{}").append('\n');
} else {
repr.append("...\n");
this.contentsSelection.internalToString(repr, prefix + " ");
}
repr.append(prefix).append("buyableContents=");
if (this.buyableContents.isEmpty()) {
repr.append("{}").append('\n');
} else {
repr.append("(").append(this.buyableContents.size()).append(" elements)...\n");
for (int i = 0; i < this.buyableContents.size(); ++i) {
final BuyableContent buyableContents_element = this.buyableContents.get(i);
buyableContents_element.internalToString(repr, prefix + i + "/ ");
}
}
}
/**
* Sets the values of the properties of a specific <tt>ColibriConferenceIQ</tt> to the values of
* the respective properties of this instance. Thus, the specified <tt>iq</tt> may be thought of
* as a description of this instance.
*
* <p><b>Note</b>: The copying of the values is deep i.e. the <tt>Contents</tt>s of this instance
* are described in the specified <tt>iq</tt>.
*
* @param iq the <tt>ColibriConferenceIQ</tt> to set the values of the properties of this instance
* on
*/
public void describeDeep(ColibriConferenceIQ iq) {
describeShallow(iq);
if (isRecording()) {
ColibriConferenceIQ.Recording recordingIQ =
new ColibriConferenceIQ.Recording(State.ON.toString());
recordingIQ.setDirectory(getRecordingDirectory());
iq.setRecording(recordingIQ);
}
for (Content content : getContents()) {
ColibriConferenceIQ.Content contentIQ = iq.getOrCreateContent(content.getName());
for (Channel channel : content.getChannels()) {
if (channel instanceof SctpConnection) {
ColibriConferenceIQ.SctpConnection sctpConnectionIQ =
new ColibriConferenceIQ.SctpConnection();
channel.describe(sctpConnectionIQ);
contentIQ.addSctpConnection(sctpConnectionIQ);
} else {
ColibriConferenceIQ.Channel channelIQ = new ColibriConferenceIQ.Channel();
channel.describe(channelIQ);
contentIQ.addChannel(channelIQ);
}
}
}
}
/**
* Add the modifier and type for the member in the member summary.
*
* @param member the member to add the type for
* @param type the type to add
* @param tdSummaryType the content tree to which the modified and type will be added
*/
protected void addModifierAndType(ProgramElementDoc member, Type type, Content tdSummaryType) {
HtmlTree code = new HtmlTree(HtmlTag.CODE);
addModifier(member, code);
if (type == null) {
if (member.isClass()) {
code.addContent("class");
} else {
code.addContent("interface");
}
code.addContent(writer.getSpace());
} else {
if (member instanceof ExecutableMemberDoc
&& ((ExecutableMemberDoc) member).typeParameters().length > 0) {
Content typeParameters =
((AbstractExecutableMemberWriter) this).getTypeParameters((ExecutableMemberDoc) member);
code.addContent(typeParameters);
// Code to avoid ugly wrapping in member summary table.
if (typeParameters.charCount() > 10) {
code.addContent(new HtmlTree(HtmlTag.BR));
} else {
code.addContent(writer.getSpace());
}
code.addContent(
writer.getLink(
new LinkInfoImpl(configuration, LinkInfoImpl.Kind.SUMMARY_RETURN_TYPE, type)));
} else {
code.addContent(
writer.getLink(
new LinkInfoImpl(configuration, LinkInfoImpl.Kind.SUMMARY_RETURN_TYPE, type)));
}
}
tdSummaryType.addContent(code);
}
/**
* Notifies this <tt>Conference</tt> that the ordered list of <tt>Endpoint</tt>s of {@link
* #speechActivity} i.e. the dominant speaker history has changed.
*
* <p>This instance notifies the video <tt>Channel</tt>s about the change so that they may update
* their last-n lists and report to this instance which <tt>Endpoint</tt>s are to be asked for
* video keyframes.
*/
private void speechActivityEndpointsChanged() {
List<Endpoint> endpoints = null;
for (Content content : getContents()) {
if (MediaType.VIDEO.equals(content.getMediaType())) {
Set<Endpoint> endpointsToAskForKeyframes = null;
endpoints = speechActivity.getEndpoints();
for (Channel channel : content.getChannels()) {
if (!(channel instanceof RtpChannel)) continue;
RtpChannel rtpChannel = (RtpChannel) channel;
List<Endpoint> channelEndpointsToAskForKeyframes =
rtpChannel.speechActivityEndpointsChanged(endpoints);
if ((channelEndpointsToAskForKeyframes != null)
&& !channelEndpointsToAskForKeyframes.isEmpty()) {
if (endpointsToAskForKeyframes == null) {
endpointsToAskForKeyframes = new HashSet<>();
}
endpointsToAskForKeyframes.addAll(channelEndpointsToAskForKeyframes);
}
}
if ((endpointsToAskForKeyframes != null) && !endpointsToAskForKeyframes.isEmpty()) {
content.askForKeyframes(endpointsToAskForKeyframes);
}
}
}
}
/**
* Build the summaries for the methods that belong to the given class.
*
* @param node the XML element that specifies which components to document
* @param classContentTree content tree to which the documentation will be added
*/
public void buildSerializableMethods(XMLNode node, Content classContentTree) {
Content serializableMethodTree = methodWriter.getSerializableMethodsHeader();
MemberDoc[] members = currentClass.serializationMethods();
int membersLength = members.length;
if (membersLength > 0) {
for (int i = 0; i < membersLength; i++) {
currentMember = members[i];
Content methodsContentTree = methodWriter.getMethodsContentHeader((i == membersLength - 1));
buildChildren(node, methodsContentTree);
serializableMethodTree.addContent(methodsContentTree);
}
}
if (currentClass.serializationMethods().length > 0) {
classContentTree.addContent(
methodWriter.getSerializableMethods(
configuration.getText("doclet.Serialized_Form_methods"), serializableMethodTree));
if (currentClass.isSerializable() && !currentClass.isExternalizable()) {
if (currentClass.serializationMethods().length == 0) {
Content noCustomizationMsg =
methodWriter.getNoCustomizationMsg(
configuration.getText("doclet.Serializable_no_customization"));
classContentTree.addContent(
methodWriter.getSerializableMethods(
configuration.getText("doclet.Serialized_Form_methods"), noCustomizationMsg));
}
}
}
}
/** {@inheritDoc} */
protected void addNavDetailLink(boolean link, Content liNav) {
if (link) {
liNav.addContent(
writer.getHyperLink(
SectionName.CONSTRUCTOR_DETAIL, writer.getResource("doclet.navConstructor")));
} else {
liNav.addContent(writer.getResource("doclet.navConstructor"));
}
}
/**
* Add the deprecated information for the given member.
*
* @param member the member being documented.
* @param contentTree the content tree to which the deprecated information will be added.
*/
protected void addDeprecatedInfo(ProgramElementDoc member, Content contentTree) {
Content output =
(new DeprecatedTaglet()).getTagletOutput(member, writer.getTagletWriterInstance(false));
if (!output.isEmpty()) {
Content deprecatedContent = output;
Content div = HtmlTree.DIV(HtmlStyle.block, deprecatedContent);
contentTree.addContent(div);
}
}
/** {@inheritDoc} */
public Content getConstructorDetailsTreeHeader(ClassDoc classDoc, Content memberDetailsTree) {
memberDetailsTree.addContent(HtmlConstants.START_OF_CONSTRUCTOR_DETAILS);
Content constructorDetailsTree = writer.getMemberTreeHeader();
constructorDetailsTree.addContent(writer.getMarkerAnchor(SectionName.CONSTRUCTOR_DETAIL));
Content heading =
HtmlTree.HEADING(HtmlConstants.DETAILS_HEADING, writer.constructorDetailsLabel);
constructorDetailsTree.addContent(heading);
return constructorDetailsTree;
}
@Override
public int serializedSize() {
int size = 0;
size += 2;
for (int i = 0; i < this.gems.size(); ++i) {
final Content gems_element = this.gems.get(i);
size += gems_element.serializedSize();
}
return size;
}
/**
* Build the member details contents of the page.
*
* @param node the XML element that specifies which components to document
* @param annotationContentTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeMemberDetails(XMLNode node, Content annotationContentTree) {
Content memberDetailsTree = writer.getMemberTreeHeader();
buildChildren(node, memberDetailsTree);
if (memberDetailsTree.isValid()) {
Content memberDetails = writer.getMemberTreeHeader();
writer.addAnnotationDetailsMarker(memberDetails);
memberDetails.addContent(writer.getMemberTree(memberDetailsTree));
annotationContentTree.addContent(writer.getMemberDetailsTree(memberDetails));
}
}
private int getComponentNumNamed(String s) {
for (int i = 0; i < getContentManager().getContentCount(); i++) {
final Content content = getContentManager().getContent(i);
if (content != null && s.equals(content.getDisplayName())) {
return i;
}
}
return -1;
}
/**
* Finds a <tt>Channel</tt> of this <tt>Conference</tt> which receives a specific SSRC and is with
* a specific <tt>MediaType</tt>.
*
* @param receiveSSRC the SSRC of a received RTP stream whose receiving <tt>Channel</tt> in this
* <tt>Conference</tt> is to be found
* @param mediaType the <tt>MediaType</tt> of the <tt>Channel</tt> to be found
* @return the <tt>Channel</tt> in this <tt>Conference</tt> which receives the specified
* <tt>ssrc</tt> and is with the specified <tt>mediaType</tt>; otherwise, <tt>null</tt>
*/
public Channel findChannelByReceiveSSRC(long receiveSSRC, MediaType mediaType) {
for (Content content : getContents()) {
if (mediaType.equals(content.getMediaType())) {
Channel channel = content.findChannelByReceiveSSRC(receiveSSRC);
if (channel != null) return channel;
}
}
return null;
}
@Nullable
private static Content getRunContentByDescriptor(
final ContentManager contentManager, final RunContentDescriptor descriptor) {
final Content[] contents = contentManager.getContents();
for (final Content content : contents) {
if (descriptor.equals(content.getUserData(DESCRIPTOR_KEY))) {
return content;
}
}
return null;
}
public final void internalToString(final StringBuilder repr, final String prefix) {
repr.append(prefix).append("gems=");
if (this.gems.isEmpty()) {
repr.append("{}").append('\n');
} else {
repr.append("(").append(this.gems.size()).append(" elements)...\n");
for (int i = 0; i < this.gems.size(); ++i) {
final Content gems_element = this.gems.get(i);
gems_element.internalToString(repr, prefix + i + "/ ");
}
}
}
@Nullable
private RunContentDescriptor getDescriptorBy(ProcessHandler handler, Executor runnerInfo) {
ContentManager contentManager = getContentManagerForRunner(runnerInfo);
Content[] contents = contentManager.getContents();
for (Content content : contents) {
RunContentDescriptor runContentDescriptor = content.getUserData(DESCRIPTOR_KEY);
if (runContentDescriptor.getProcessHandler() == handler) {
return runContentDescriptor;
}
}
return null;
}
public void showRunContent(
@NotNull final Executor info,
RunContentDescriptor descriptor,
RunContentDescriptor contentToReuse) {
if (contentToReuse != null) {
final Content attachedContent = contentToReuse.getAttachedContent();
if (attachedContent.getManager() != null) {
descriptor.setAttachedContent(attachedContent);
}
}
showRunContent(info, descriptor);
}
/**
* {@inheritDoc}
*
* <p>Creates a <tt>TransportManager</tt> instance suitable for an <tt>SctpConnection</tt> (e.g.
* with 1 component only).
*/
protected TransportManager createTransportManager(String xmlNamespace) throws IOException {
if (IceUdpTransportPacketExtension.NAMESPACE.equals(xmlNamespace)) {
Content content = getContent();
return new IceUdpTransportManager(
content.getConference(), isInitiator(), 1 /* num components */, content.getName());
} else if (RawUdpTransportPacketExtension.NAMESPACE.equals(xmlNamespace)) {
// TODO: support RawUdp once RawUdpTransportManager is updated
// return new RawUdpTransportManager(this);
throw new IllegalArgumentException("Unsupported Jingle transport " + xmlNamespace);
} else {
throw new IllegalArgumentException("Unsupported Jingle transport " + xmlNamespace);
}
}
/** Generate the package use list. */
protected void generatePackageUseFile() throws IOException {
Content body = getPackageUseHeader();
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.contentContainer);
if (usingPackageToUsedClasses.isEmpty()) {
div.addContent(getResource("doclet.ClassUse_No.usage.of.0", pkgdoc.name()));
} else {
addPackageUse(div);
}
body.addContent(div);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
@Override
public boolean unserialize(final ByteBuffer buffer) {
final int gems_size = buffer.getShort() & 0xFFFF;
this.gems.clear();
this.gems.ensureCapacity(gems_size);
for (int i = 0; i < gems_size; ++i) {
final Content gems_element = new Content();
final boolean gems_element_ok = gems_element.unserialize(buffer);
if (!gems_element_ok) {
return false;
}
this.gems.add(gems_element);
}
return true;
}
/**
* Add the package use information.
*
* @param pkg the package that used the given package
* @param contentTree the content tree to which the information will be added
*/
protected void addPackageUse(PackageDoc pkg, Content contentTree) throws IOException {
Content tdFirst =
HtmlTree.TD(
HtmlStyle.colFirst,
getHyperLink(Util.getPackageName(pkg), new StringContent(Util.getPackageName(pkg))));
contentTree.addContent(tdFirst);
HtmlTree tdLast = new HtmlTree(HtmlTag.TD);
tdLast.addStyle(HtmlStyle.colLast);
if (pkg != null && pkg.name().length() != 0) {
addSummaryComment(pkg, tdLast);
} else {
tdLast.addContent(getSpace());
}
contentTree.addContent(tdLast);
}
/** {@inheritDoc} */
public Content getSignature(ConstructorDoc constructor) {
Content pre = new HtmlTree(HtmlTag.PRE);
writer.addAnnotationInfo(constructor, pre);
addModifiers(constructor, pre);
if (configuration.linksource) {
Content constructorName = new StringContent(constructor.name());
writer.addSrcLink(constructor, constructorName, pre);
} else {
addName(constructor.name(), pre);
}
int indent = pre.charCount();
addParameters(constructor, pre, indent);
addExceptions(constructor, pre, indent);
return pre;
}
private Content createNewContent(
final ContentManager contentManager,
final RunContentDescriptor descriptor,
Executor executor) {
final String processDisplayName = descriptor.getDisplayName();
final Content content =
ContentFactory.SERVICE
.getInstance()
.createContent(descriptor.getComponent(), processDisplayName, true);
content.putUserData(DESCRIPTOR_KEY, descriptor);
content.putUserData(ToolWindow.SHOW_CONTENT_ICON, Boolean.TRUE);
contentManager.addContent(content);
new CloseListener(content, executor);
return content;
}
@Override
public boolean serialize(final ByteBuffer buffer) {
if (this.gems.size() > 65535) {
return false;
}
buffer.putShort((short) this.gems.size());
for (int i = 0; i < this.gems.size(); ++i) {
final Content gems_element = this.gems.get(i);
final boolean gems_element_ok = gems_element.serialize(buffer);
if (!gems_element_ok) {
return false;
}
}
return true;
}
/**
* Expires this <tt>Conference</tt>, its <tt>Content</tt>s and their respective <tt>Channel</tt>s.
* Releases the resources acquired by this instance throughout its life time and prepares it to be
* garbage collected.
*/
public void expire() {
synchronized (this) {
if (expired) return;
else expired = true;
}
EventAdmin eventAdmin = videobridge.getEventAdmin();
if (eventAdmin != null) eventAdmin.sendEvent(EventFactory.conferenceExpired(this));
setRecording(false);
if (recorderEventHandler != null) {
recorderEventHandler.close();
recorderEventHandler = null;
}
Videobridge videobridge = getVideobridge();
try {
videobridge.expireConference(this);
} finally {
// Expire the Contents of this Conference.
for (Content content : getContents()) {
try {
content.expire();
} catch (Throwable t) {
logger.warn(
"Failed to expire content " + content.getName() + " of conference " + getID() + "!",
t);
if (t instanceof InterruptedException) Thread.currentThread().interrupt();
else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
}
// Close the transportManagers of this Conference. Normally, there
// will be no TransportManager left to close at this point because
// all Channels have expired and the last Channel to be removed from
// a TransportManager closes the TransportManager. However, a
// Channel may have expired before it has learned of its
// TransportManager and then the TransportManager will not close.
closeTransportManagers();
if (logger.isInfoEnabled()) {
logger.info(
"Expired conference " + getID() + ". " + videobridge.getConferenceCountString());
}
}
}
/**
* Get the header for the package use listing.
*
* @return a content tree representing the package use header
*/
protected Content getPackageUseHeader() {
String packageText = configuration.getText("doclet.Package");
String name = pkgdoc.name();
String title = configuration.getText("doclet.Window_ClassUse_Header", packageText, name);
Content bodyTree = getBody(true, getWindowTitle(title));
addTop(bodyTree);
addNavLinks(true, bodyTree);
ContentBuilder headContent = new ContentBuilder();
headContent.addContent(getResource("doclet.ClassUse_Title", packageText));
headContent.addContent(new HtmlTree(HtmlTag.BR));
headContent.addContent(name);
Content heading =
HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true, HtmlStyle.title, headContent);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
bodyTree.addContent(div);
return bodyTree;
}
/**
* Build the member summary contents of the page.
*
* @param node the XML element that specifies which components to document
* @param annotationContentTree the content tree to which the documentation will be added
*/
public void buildMemberSummary(XMLNode node, Content annotationContentTree) throws Exception {
Content memberSummaryTree = writer.getMemberTreeHeader();
configuration
.getBuilderFactory()
.getMemberSummaryBuilder(writer)
.buildChildren(node, memberSummaryTree);
annotationContentTree.addContent(writer.getMemberSummaryTree(memberSummaryTree));
}
/**
* Add the navigation summary link.
*
* @param members members to be linked
* @param visibleMemberMap the visible inherited members map
* @param liNav the content tree to which the navigation summary link will be added
*/
protected void addNavSummaryLink(
List<?> members, VisibleMemberMap visibleMemberMap, Content liNav) {
if (members.size() > 0) {
liNav.addContent(getNavSummaryLink(null, true));
return;
}
ClassDoc icd = classdoc.superclass();
while (icd != null) {
List<?> inhmembers = visibleMemberMap.getMembersFor(icd);
if (inhmembers.size() > 0) {
liNav.addContent(getNavSummaryLink(icd, true));
return;
}
icd = icd.superclass();
}
liNav.addContent(getNavSummaryLink(null, false));
}
public static void showImage(Long id) {
Content content = Content.findById(id);
notFoundIfNull(content);
response.setContentTypeIfNotSet(content.image.type());
File file = content.image.getFile();
notFoundIfNull(file);
renderBinary(file);
}