Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  //
  //  ========================================================================
  //  Copyright (c) 1995-2012 Mort Bay Consulting Pty. Ltd.
  //  ------------------------------------------------------------------------
  //  All rights reserved. This program and the accompanying materials
  //  are made available under the terms of the Eclipse Public License v1.0
  //  and Apache License v2.0 which accompanies this distribution.
  //
  //      The Eclipse Public License is available at
 //      http://www.eclipse.org/legal/epl-v10.html
 //
 //      The Apache License v2.0 is available at
 //      http://www.opensource.org/licenses/apache2.0.php
 //
 //  You may elect to redistribute this code under either of these licenses.
 //  ========================================================================
 //
 
 package org.eclipse.jetty.util.component;
 
 
Basic implementation of the life cycle interface for components.
 
 public abstract class AbstractLifeCycle implements LifeCycle
 {
     private static final Logger LOG = Log.getLogger(AbstractLifeCycle.class);
     public static final String STOPPED="STOPPED";
     public static final String FAILED="FAILED";
     public static final String STARTING="STARTING";
     public static final String STARTED="STARTED";
     public static final String STOPPING="STOPPING";
     public static final String RUNNING="RUNNING";
     
     private final Object _lock = new Object();
     private final int __FAILED = -1, __STOPPED = 0, __STARTING = 1, __STARTED = 2, __STOPPING = 3;
     private volatile int _state = ;
     
 
     protected void doStart() throws Exception
     {
     }
 
     protected void doStop() throws Exception
     {
     }
 
     public final void start() throws Exception
     {
         synchronized ()
         {
             try
             {
                 if ( ==  ||  == )
                     return;
                 setStarting();
                 doStart();
                 setStarted();
             }
             catch (Exception e)
             {
                 setFailed(e);
                 throw e;
             }
             catch (Error e)
             {
                 setFailed(e);
                 throw e;
             }
         }
     }
 
     public final void stop() throws Exception
     {
         synchronized ()
         {
             try
             {
                 if ( ==  ||  == )
                     return;
                 setStopping();
                 doStop();
                 setStopped();
             }
             catch (Exception e)
             {
                 setFailed(e);
                 throw e;
             }
             catch (Error e)
             {
                 setFailed(e);
                throw e;
            }
        }
    }
    public boolean isRunning()
    {
        final int state = ;
        
        return state ==  || state == ;
    }
    public boolean isStarted()
    {
        return  == ;
    }
    public boolean isStarting()
    {
        return  == ;
    }
    public boolean isStopping()
    {
        return  == ;
    }
    public boolean isStopped()
    {
        return  == ;
    }
    public boolean isFailed()
    {
        return  == ;
    }
    public void addLifeCycleListener(LifeCycle.Listener listener)
    {
        .add(listener);
    }
    public void removeLifeCycleListener(LifeCycle.Listener listener)
    {
        .remove(listener);
    }
    
    public String getState()
    {
        switch()
        {
            case return ;
            case return ;
            case return ;
            case return ;
            case return ;
        }
        return null;
    }
    
    public static String getState(LifeCycle lc)
    {
        if (lc.isStarting()) return ;
        if (lc.isStarted()) return ;
        if (lc.isStopping()) return ;
        if (lc.isStopped()) return ;
        return ;
    }
    private void setStarted()
    {
         = ;
        .debug(+" {}",this);
        for (Listener listener : )
            listener.lifeCycleStarted(this);
    }
    private void setStarting()
    {
        .debug("starting {}",this);
         = ;
        for (Listener listener : )
            listener.lifeCycleStarting(this);
    }
    private void setStopping()
    {
        .debug("stopping {}",this);
         = ;
        for (Listener listener : )
            listener.lifeCycleStopping(this);
    }
    private void setStopped()
    {
         = ;
        .debug("{} {}",,this);
        for (Listener listener : )
            listener.lifeCycleStopped(this);
    }
    private void setFailed(Throwable th)
    {
         = ;
        .warn(+" " + this+": "+th,th);
        for (Listener listener : )
            listener.lifeCycleFailure(this,th);
    }
    public static abstract class AbstractLifeCycleListener implements LifeCycle.Listener
    {
        public void lifeCycleFailure(LifeCycle eventThrowable cause) {}
        public void lifeCycleStarted(LifeCycle event) {}
        public void lifeCycleStarting(LifeCycle event) {}
        public void lifeCycleStopped(LifeCycle event) {}
        public void lifeCycleStopping(LifeCycle event) {}
    }
New to GrepCode? Check out our FAQ X