Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
   *
   * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
   * Other names may be trademarks of their respective owners.
   *
   * The contents of this file are subject to the terms of either the GNU
  * General Public License Version 2 only ("GPL") or the Common
  * Development and Distribution License("CDDL") (collectively, the
  * "License"). You may not use this file except in compliance with the
  * License. You can obtain a copy of the License at
  * http://www.netbeans.org/cddl-gplv2.html
  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
  * specific language governing permissions and limitations under the
  * License.  When distributing the software, include this License Header
  * Notice in each file and include the License file at
  * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the GPL Version 2 section of the License file that
  * accompanied this code. If applicable, add the following below the
  * License Header, with the fields enclosed by brackets [] replaced by
  * your own identifying information:
  * "Portions Copyrighted [year] [name of copyright owner]"
  *
  * Contributor(s):
  * The Original Software is NetBeans. The Initial Developer of the Original
  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
  * Microsystems, Inc. All Rights Reserved.
  *
  * If you wish your version of this file to be governed by only the CDDL
  * or only the GPL Version 2, indicate your decision by adding
  * "[Contributor] elects to include this software in this distribution
  * under the [CDDL or GPL Version 2] license." If you do not indicate a
  * single choice of license, a recipient has the option to distribute
  * your version of this file under either the CDDL, the GPL Version 2 or
  * to extend the choice of license to its licensees as provided above.
  * However, if you add GPL Version 2 code and therefore, elected the GPL
  * Version 2 license, then the option applies only if the new code is
  * made subject to such option by the copyright holder.
  */
 
 package org.netbeans.modules.profiler.ppoints;
 
 import java.io.File;
Abstract superclass for all Profiling Points defined in source code

Author(s):
Tomas Hurka
Jiri Sedlacek
 
 public abstract class CodeProfilingPoint extends ProfilingPoint {
     //~ Inner Classes ------------------------------------------------------------------------------------------------------------
 
     public abstract static class Paired extends CodeProfilingPoint {
         //~ Instance fields ------------------------------------------------------------------------------------------------------
 
         private Location endLocation// End location of the Profiling Point
         private Location startLocation// Start location of the Profiling Point
 
         //~ Constructors ---------------------------------------------------------------------------------------------------------
 
         Paired(String nameLocation startLocationLocation endLocationLookup.Provider  projectProfilingPointFactory factory) {
             super(nameprojectfactory);
             this. = startLocation;
             this. = endLocation;
         }
 
         //~ Methods --------------------------------------------------------------------------------------------------------------
         
         public boolean isValid() {
             // TODO: should also check line number!
             if ( == nullreturn false;
             String filename = .getFile();
             File file = new File(filename);
             if (!filename.endsWith(".java") || !file.exists() || !file.isFile()) return false// NOI18N
             
             if (!usesEndLocation()) return true;
             
             // TODO: should also check line number!
             if ( == nullreturn false;
             filename = .getFile();
             file = new File(filename);
             return filename.endsWith(".java") && file.exists() && file.isFile(); // NOI18N
         }
 
         public void setEnabled(boolean enabled) {
             if (isEnabled() != enabled) {
                 super.setEnabled(enabled);
                 getStartAnnotation().fireTypeChanged();
 
                 if (usesEndLocation()) {
                    getEndAnnotation().fireTypeChanged();
                }
            }
        }
        public void setEndLocation(Location endLocation) {
            if (((this. == null) && (endLocation == null))
                    || ((this. != null) && this..equals(endLocation))) {
                return;
            }
            Annotation oldAnnotation = getEndAnnotation();
            Location oldLocation = this.;
            this. = endLocation;
            Annotation newAnnotation = getEndAnnotation();
            getChangeSupport()
                .firePropertyChange(,
                                    (oldAnnotation == null) ? new Annotation[0] : new Annotation[] { oldAnnotation },
                                    (newAnnotation == null) ? new Annotation[0] : new Annotation[] { newAnnotation });
            getChangeSupport()
                .firePropertyChange(,
                                    (oldLocation == null) ? . : oldLocation,
                                    (endLocation == null) ? . : endLocation);
        }
        public Location getEndLocation() {
            return ;
        }
        public void setStartLocation(Location startLocation) {
            if (this..equals(startLocation)) {
                return;
            }
            Annotation oldAnnotation = getStartAnnotation();
            Location oldLocation = this.;
            this. = startLocation;
            Annotation newAnnotation = getStartAnnotation();
            getChangeSupport()
                .firePropertyChange(new Annotation[] { oldAnnotation }, new Annotation[] { newAnnotation });
            getChangeSupport()
                .firePropertyChange(oldLocationstartLocation);
        }
        public Location getStartLocation() {
            return ;
        }
            if (rpp1 == nullreturn new RuntimeProfilingPoint[0]; // Cannot create RPP, wrong location
            if (usesEndLocation()) {
                RuntimeProfilingPoint rpp2 = createRuntimeProfilingPoint(getEndLocation());
                if (rpp2 == nullreturn new RuntimeProfilingPoint[0]; // Cannot create RPP, wrong location
                return new RuntimeProfilingPoint[] { rpp1rpp2 };
            } else {
                return new RuntimeProfilingPoint[] { rpp1 };
            }
        }
        protected abstract Annotation getEndAnnotation();
        protected abstract Annotation getStartAnnotation();
        protected abstract boolean usesEndLocation();
        protected void timeAdjust(final int threadIdfinal long timeDiff0final long timeDiff1) {
        }
        public CodeProfilingPoint.Annotation[] getAnnotations() {
            return usesEndLocation() ? new CodeProfilingPoint.Annotation[] { getStartAnnotation(), getEndAnnotation() }
                                     : new CodeProfilingPoint.Annotation[] { getStartAnnotation() };
        }
        
        public void setLocation(Annotation annotationLocation location) {
            if (annotation.equals(getStartAnnotation())) {
                setStartLocation(location);
            } else if (annotation.equals(getEndAnnotation())) {
                setEndLocation(location);
            }
        }
        Location getLocation(Annotation annotation) {
            if (annotation.equals(getStartAnnotation())) {
                return getStartLocation();
            } else if (annotation.equals(getEndAnnotation())) {
                return getEndLocation();
            }
            return null;
        }
    }
    public abstract static class Single extends CodeProfilingPoint {
        //~ Instance fields ------------------------------------------------------------------------------------------------------
        private Location location// Location of the Profiling Point
        //~ Constructors ---------------------------------------------------------------------------------------------------------
        Single(String nameLocation locationLookup.Provider  projectProfilingPointFactory factory) {
            super(nameprojectfactory);
            this. = location;
        }
        //~ Methods --------------------------------------------------------------------------------------------------------------
        
        public boolean isValid() {
            // TODO: should also check line number!
            if ( == nullreturn false;
            String filename = .getFile();
            File file = new File(filename);
            return filename.endsWith(".java") && file.exists() && file.isFile(); // NOI18N
        }
        public void setEnabled(boolean enabled) {
            if (isEnabled() != enabled) {
                super.setEnabled(enabled);
                getAnnotation().fireTypeChanged();
            }
        }
        public void setLocation(Location location) {
            if (this..equals(location)) {
                return;
            }
            
            Annotation oldAnnotation = getAnnotation();
            Location oldLocation = this.;
            this. = location;
            Annotation newAnnotation = getAnnotation();
            getChangeSupport()
                .firePropertyChange(new Annotation[] { oldAnnotation }, new Annotation[] { newAnnotation });
            getChangeSupport()
                .firePropertyChange(oldLocationlocation);
        }
        public Location getLocation() {
            return ;
        }
            if (rpp == nullreturn new RuntimeProfilingPoint[0]; // Cannot create RPP, wrong location
            return new RuntimeProfilingPoint[] { rpp };
        }
        protected abstract Annotation getAnnotation();
        public CodeProfilingPoint.Annotation[] getAnnotations() {
            return new CodeProfilingPoint.Annotation[] { getAnnotation() };
        }
        
        public void setLocation(Annotation annotationLocation location) {
            if (annotation.equals(getAnnotation())) setLocation(location);
        }
        Location getLocation(Annotation annotation) {
            if (annotation.equals(getAnnotation())) {
                return getLocation();
            }
            return null;
        }
    }
    public static final class Location {
        //~ Static fields/initializers -------------------------------------------------------------------------------------------
        public static final String PROPERTY_LOCATION_FILE = "p_location_file"// NOI18N
        public static final String PROPERTY_LOCATION_LINE = "p_location_line"// NOI18N
        public static final String PROPERTY_LOCATION_OFFSET = "p_location_offset"// NOI18N
        public static final int OFFSET_START = .;
        public static final int OFFSET_END = .;
        public static final Location EMPTY = new Location("", 0, ); // NOI18N
        //~ Instance fields ------------------------------------------------------------------------------------------------------
        private String file;
        private int line// 1-based line
        private int offset;
        //~ Constructors ---------------------------------------------------------------------------------------------------------
        public Location(String fileint lineint offset) {
            this. = file;
            this. = line// 1-based line
            this. = offset;
        }
        //~ Methods --------------------------------------------------------------------------------------------------------------
        public String getFile() {
            return ;
        }
        public int getLine() {
            return ;
        } // 1-based line
        public boolean isLineEnd() {
            return getOffset() == ;
        }
        public boolean isLineStart() {
            return getOffset() == ;
        }
        public int getOffset() {
            return ;
        }
        public boolean equals(Object object) {
            if (!(object instanceof Location)) {
                return false;
            }
            Location location = (Locationobject;
            return .equals(location.file// Should compare resolved FileObjects
                   && ( == location.line) && ( == location.offset);
        }
        @Override
        public int hashCode() {
            int hash = 7;
            hash = 79 * hash + (this. != null ? this..hashCode() : 0);
            hash = 79 * hash + this.;
            hash = 79 * hash + this.;
            return hash;
        }
        public static Location load(Lookup.Provider  projectint indexProperties properties) {
            return load(projectindexnullproperties);
        }
        public static Location load(Lookup.Provider  projectint indexString prefixProperties properties) {
            String absPrefix = (prefix == null) ? (index + "_") : (index + "_" + prefix); // NOI18N
            String relUrl = properties.getProperty(absPrefix + null);
            String lineStr = properties.getProperty(absPrefix + null);
            String offsetStr = properties.getProperty(absPrefix + null);
            if ((relUrl == null) || (lineStr == null) || (offsetStr == null)) {
                return null;
            }
            Location location = null;
            String url = Utils.getAbsolutePath(projectrelUrl);
            try {
                location = new Location(url, Integer.parseInt(lineStr), Integer.parseInt(offsetStr));
            } catch (Exception e) {
                ErrorManager.getDefault().log(.e.getMessage());
            }
            return location;
        }
        public void store(Lookup.Provider  projectint indexProperties properties) {
            store(projectindexnullproperties);
        }
        public void store(Lookup.Provider  projectint indexString prefixProperties properties) {
            String absPrefix = (prefix == null) ? (index + "_") : (index + "_" + prefix); // NOI18N
            properties.put(absPrefix + , Utils.getRelativePath(project));
            properties.put(absPrefix + , Integer.toString());
            properties.put(absPrefix + , Integer.toString());
        }
        public String toString() {
            return "File: " + getFile() + ", line: " + getLine() + ", offset: " + getOffset(); // NOI18N
        }
    }
    
    public abstract static class Annotation extends org.openide.text.Annotation {
        //~ Methods --------------------------------------------------------------------------------------------------------------
        public abstract CodeProfilingPoint profilingPoint();
        void fireDescriptionChanged() {
            firePropertyChange(falsetrue);
        }
        void fireTypeChanged() {
            firePropertyChange(falsetrue);
        }
    }
    //~ Static fields/initializers -----------------------------------------------------------------------------------------------
    static final String PROPERTY_LOCATION = "p_location"// NOI18N
    static final String PROPERTY_ANNOTATION = "p_annotation"// NOI18N
    //~ Constructors -------------------------------------------------------------------------------------------------------------
    CodeProfilingPoint(String nameLookup.Provider  projectProfilingPointFactory factory) {
        super(nameprojectfactory);
    }
    //~ Methods ------------------------------------------------------------------------------------------------------------------
    // returns first defined location
    public Location getLocation() {
        Annotation firstAnnotation = getAnnotations()[0];
        return (firstAnnotation == null) ? null : getLocation(firstAnnotation);
    }
    public abstract Annotation[] getAnnotations();
    
    abstract void setLocation(Annotation annotationLocation location);
    abstract Location getLocation(Annotation annotation);
    }
    String getServerInfo() {
        return null;
    }
        ProfilingPointsManager ppManager = ProfilingPointsManager.getDefault();
        String className = Utils.getClassName(location);
        if (className == nullreturn null// Classname cannot be resolved, most likely invalid location
                                         classNamelocation.getLine(), location.getOffset(),
                                         getServerHandlerClassName(), getServerInfo());
    }
    abstract void hit(RuntimeProfilingPoint.HitEvent hitEventint index);
    // used for updating location when editor line is moved, do not use!!!
    void internalUpdateLocation(Annotation annotationint line) {
        Location location = getLocation(annotation);
        if (location != null) {
            location.line = line;
        }
    }
New to GrepCode? Check out our FAQ X