gt:         if (group != null) {
context: /*
   * Copyright (c) 2003 Sun Microsystems, Inc.  All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *       Sun Microsystems, Inc. for Project JXTA."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact Project JXTA at http://www.jxta.org.
   *
   * 5. Products derived from this software may not be called "JXTA",
   *    nor may "JXTA" appear in their name, without prior written
   *    permission of Sun.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL SUN MICROSYSTEMS OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of Project JXTA.  For more
   * information on Project JXTA, please see
   * <http://www.jxta.org/>.
   *
   * This license is based on the BSD license adopted by the Apache Foundation.
   *
   * $Id: LightWeightPeerGroup.java,v 1.1 2007/01/16 11:02:11 thomas Exp $
   */
  
  package net.jxta.peergroup;
  
  import java.io.IOException;
  import java.util.Iterator;
  import java.util.Collections;
  
  import net.jxta.access.AccessService;
  import net.jxta.discovery.DiscoveryService;
  import net.jxta.document.Advertisement;
  import net.jxta.document.Element;
  import net.jxta.endpoint.EndpointService;
  import net.jxta.exception.ServiceNotFoundException;
  import net.jxta.exception.PeerGroupException;
  import net.jxta.exception.ProtocolNotSupportedException;
  import net.jxta.id.ID;
  import net.jxta.membership.MembershipService;
  import net.jxta.peer.PeerID;
  import net.jxta.peer.PeerInfoService;
  import net.jxta.pipe.PipeService;
  import net.jxta.platform.JxtaLoader;
  import net.jxta.platform.Module;
  import net.jxta.platform.ModuleSpecID;
  import net.jxta.protocol.PeerAdvertisement;
  import net.jxta.protocol.PeerGroupAdvertisement;
  import net.jxta.protocol.ModuleImplAdvertisement;
  import net.jxta.protocol.ConfigParams;
  import net.jxta.rendezvous.RendezVousService;
  import net.jxta.resolver.ResolverService;
  import net.jxta.service.Service;
  
  import org.apache.log4j.Level;
  import org.apache.log4j.Logger;
  
  /**
   * LightWeightPeerGroup is a class intended to help
   * building PeerGroup that can inherit one or more
   * services from a parent PeerGroup.
   *
   * An LightWeightPeerGroup implements PeerGroup and is to
   * be used like a PeerGroup by applications.
   *
   * This class is intended to be extended/implemented.
   *
   * Note: unlike implementations of peer groups that existed until JXTA 2.2, 
   * LightweightPeergroup permits to implement groups that borrow all or 
   * part of their services to a parent group. One needs to remember 
   * that peers in various such subgroups of a given parent groups may 
   * implicitly all share the same services if that is what the PeerGroup
   * implementing LightWeightPeerGroup is doing. Please refer to the documentation
   * of PeerGroups extending LightWeigthPeerGroup do understand which
   * services are shared, and which are not.
   *
   **/
  
  public class LightWeightPeerGroup implements PeerGroup {
  
  	private static final Logger LOG = Logger.getLogger(LightWeightPeerGroup.class.getName());
  
      private PeerGroup group = null;
      private ID assignedID  = null;
      private Advertisement implAdv = null;
      private PeerGroupAdvertisement adv = null;
  
      /**
       * Constructor
       *
       * All classes that extend this class must invoke this
       * constructor.
       *
       * @param adv PeerGroupAdvertisement of this LightWeightPeerGroup.
       * Note that only the PeerGroupID is used.
       **/
      public LightWeightPeerGroup (PeerGroupAdvertisement adv) {
          this.adv = adv;
      }
  
      /***********************************************************
       ** Module API
       ***********************************************************/
      /**
      *	{@inheritDoc}
      **/
      public void init(PeerGroup group,
                       ID assignedID,
                       Advertisement implAdv) {
  
          this.group = group;
          this.assignedID = assignedID;
          this.implAdv = implAdv;
      }
  
  
      /**
      *	{@inheritDoc}
      **/
      public int startApp(String[] args) {
          return START_OK;
      }
  
      /**
      *	{@inheritDoc}
      **/
      public void stopApp() {
          return;
      }
  
      /**
      *	{@inheritDoc}
      **/
      public Service getInterface() {
          return this;
      }
  
      /**
      *	{@inheritDoc}
      **/
      public Advertisement getImplAdvertisement() {
          return implAdv;
      }
  
  
  
      /***********************************************************
       ** PeerGroup API
       ***********************************************************/
      /**
      *	{@inheritDoc}
      **/
      public ThreadGroup getHomeThreadGroup() {
          if (group != null) {
              return group.getHomeThreadGroup();
          } else {
              return null;
          }
      }
  
  
      /**
      *	{@inheritDoc}
      **/
      public JxtaLoader getLoader() {
          if (group != null) {
              return group.getLoader();
          } else {
              return null;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public PeerGroup getParentGroup() {
  
          try {
              return (PeerGroup) group;
          } catch (Exception ex) {
              if ( LOG.isEnabledFor(Level.DEBUG) ) {
                  LOG.debug("LightWeightPeerGroup is a base PeerGroup: no parent");
              }
              throw new RuntimeException ("LightWeightPeerGroup is a base PeerGroup: no parent");
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public boolean isRendezvous() {
  
          if (group != null) {
              return group.isRendezvous();
          } else {
              return false;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public PeerGroupAdvertisement getPeerGroupAdvertisement() {
  
          if (adv != null) {
              return adv;
          } else if (group != null) {
              return group.getPeerGroupAdvertisement();
          } else {
              return null;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public PeerAdvertisement getPeerAdvertisement() {
  
          if (group != null) {
              return group.getPeerAdvertisement();
          } else {
              return null;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public Service lookupService(ID name)
      throws ServiceNotFoundException {
  
          if (group != null) {
              return group.lookupService (name);
          } else {
              throw new ServiceNotFoundException ("Not implemented");
          }
      }
  
      /**
       *	{@inheritDoc}
       **/
      public Service lookupService(ID name, int ignoredForNow)
      throws ServiceNotFoundException {
  
          if (group != null) {
              return group.lookupService (name);
          } else {
              throw new ServiceNotFoundException ("Not implemented");
          }
      }
  
      /**
       *	{@inheritDoc}
       **/
      public Iterator getRoleMap(ID name) {
  
          if (group != null) {
              return group.getRoleMap(name);
          } else {
              // No translation; use the given name in a singleton.
              return Collections.singletonList(name).iterator();
          }
      }
  
      /**
       *	{@inheritDoc}
       **/
      public boolean compatible(Element compat) {
  
          if (group != null) {
              return group.compatible (compat);
          } else {
              return false;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public Module loadModule(ID assignedID, Advertisement impl)
      throws ProtocolNotSupportedException, PeerGroupException {
  
          if (group != null) {
              return group.loadModule (assignedID, impl);
          } else {
              throw new ProtocolNotSupportedException ("LightWeightPeerGroup does not implement this operation");
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public Module loadModule(ID assignedID, ModuleSpecID specID, int where) {
  
          if (group != null) {
              return group.loadModule (assignedID, specID, where);
          } else {
              return null;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public void publishGroup(String name, String description)
      throws IOException {
  
          if (group != null) {
              group.publishGroup (name, description);
          } else {
              throw new IOException ("Not implemented");
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public PeerGroup newGroup(Advertisement pgAdv)
      throws PeerGroupException {
  
          if (group != null) {
              return group.newGroup (pgAdv);
          } else {
              throw new PeerGroupException ("Not implemented");
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public PeerGroup newGroup(PeerGroupID gid, Advertisement impl,
                                String name, String description)
      throws PeerGroupException  {
  
          if (group != null) {
              return group.newGroup (gid, impl, name, description);
          } else {
              throw new PeerGroupException ("Not implemented");
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public PeerGroup newGroup(PeerGroupID gid)
      throws PeerGroupException  {
  
          if (group != null) {
              return group.newGroup (gid);
          } else {
              throw new PeerGroupException ("Not implemented");
          }
      }
  
  
      /*
       * shortcuts to the well-known services, in order to avoid calls to lookup.
       */
  
      /**
      *	{@inheritDoc}
      **/
      public RendezVousService getRendezVousService() {
  
          if (group != null) {
              return group.getRendezVousService();
          } else {
              return null;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public EndpointService getEndpointService() {
  
          if (group != null) {
              return group.getEndpointService();
          } else {
              return null;
          }
      }
  
      /**
      *	{@inheritDoc}
      **/
      public ResolverService getResolverService() {
  