Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.operator.scalar;
 
 
 
 import static com.facebook.presto.operator.scalar.StringFunctions.leftTrim;
 import static com.facebook.presto.operator.scalar.StringFunctions.length;
 import static com.facebook.presto.operator.scalar.StringFunctions.lower;
 import static com.facebook.presto.operator.scalar.StringFunctions.reverse;
 import static com.facebook.presto.operator.scalar.StringFunctions.rightTrim;
 import static com.facebook.presto.operator.scalar.StringFunctions.substr;
 import static com.facebook.presto.operator.scalar.StringFunctions.trim;
 import static com.facebook.presto.operator.scalar.StringFunctions.upper;
 import static io.airlift.slice.Slices.utf8Slice;
 import static java.lang.Character.MAX_CODE_POINT;
 import static java.lang.Character.SURROGATE;
 import static java.lang.Character.getType;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 import static org.openjdk.jmh.annotations.Mode.AverageTime;
 import static org.openjdk.jmh.annotations.Scope.Thread;
 
 @SuppressWarnings("MethodMayBeStatic")
 @Fork(1)
 @Warmup(iterations = 4, time = 500, timeUnit = )
 @Measurement(iterations = 5, time = 500, timeUnit = )
 {
     @Benchmark
     public long benchmarkLength(BenchmarkData data)
     {
         return length(data.getSlice());
     }
 
     @Benchmark
     {
         Slice slice = data.getSlice();
         int length = data.getLength();
         return substr(slice, (length / 2) - 1);
     }
 
     @Benchmark
     {
         Slice slice = data.getSlice();
         int length = data.getLength();
         return substr(slice, (length / 2) - 1, length / 2);
     }
 
     @Benchmark
     {
         Slice slice = data.getSlice();
         int length = data.getLength();
         return substr(slice, -((length / 2) + 1));
     }
 
     @Benchmark
     {
         Slice slice = data.getSlice();
         int length = data.getLength();
         return substr(slice, -((length / 2) + 1), length / 2);
    }
    @Benchmark
    public Slice benchmarkReverse(BenchmarkData data)
    {
        return reverse(data.getSlice());
    }
    @Benchmark
    public Slice benchmarkLeftTrim(WhitespaceData data)
    {
        return leftTrim(data.getLeftWhitespace());
    }
    @Benchmark
    {
        return rightTrim(data.getRightWhitespace());
    }
    @Benchmark
    public Slice benchmarkTrim(WhitespaceData data)
    {
        return trim(data.getBothWhitespace());
    }
    @Benchmark
    public Slice benchmarkUpper(BenchmarkData data)
    {
        return upper(data.getSlice());
    }
    @Benchmark
    public Slice benchmarkLower(BenchmarkData data)
    {
        return lower(data.getSlice());
    }
    @State()
    public static class BenchmarkData
    {
        private static final int[] ASCII_CODE_POINTS;
        private static final int[] ALL_CODE_POINTS;
        static {
             = IntStream.range(0, 0x7F)
                    .toArray();
             = IntStream.range(0, )
                    .filter(codePoint -> getType(codePoint) != )
                    .toArray();
        }
        @Param({ "2""5""10""100""1000""10000" })
        private int length;
        @Param({ "true""false" })
        private boolean ascii;
        private Slice slice;
        private int[] codePoints;
        @Setup
        public void setup()
        {
            int[] codePointSet =  ?  : ;
            ThreadLocalRandom random = ThreadLocalRandom.current();
             = new int[];
            DynamicSliceOutput sliceOutput = new DynamicSliceOutput( * 4);
            for (int i = 0; i < .i++) {
                int codePoint = codePointSet[random.nextInt(codePointSet.length)];
                [i] = codePoint;
                sliceOutput.appendBytes(new String(Character.toChars(codePoint)).getBytes(.));
            }
             = sliceOutput.slice();
        }
        public Slice getSlice()
        {
            return ;
        }
        public int getLength()
        {
            return ;
        }
    }
    @State()
    public static class WhitespaceData
    {
        private static final int[] ASCII_WHITESPACE;
        private static final int[] ALL_WHITESPACE;
        static {
             = IntStream.range(0, 0x7F)
                    .filter(Character::isWhitespace)
                    .toArray();
             = IntStream.range(0, )
                    .filter(Character::isWhitespace)
                    .toArray();
        }
        @Param({ "2""5""10""100""1000""10000" })
        private int length;
        @Param({ "true""false" })
        private boolean ascii;
        private Slice leftWhitespace;
        private Slice rightWhitespace;
        private Slice bothWhitespace;
        @Setup
        public void setup()
        {
            Slice whitespace = createRandomUtf8Slice( ?  :  + 1);
             = Slices.copyOf(whitespace);
            .setByte(.length() - 1, 'X');
             = Slices.copyOf(whitespace);
            .setByte(0, 'X');
             = Slices.copyOf(whitespace);
            .setByte( / 2, 'X');
        }
        private static Slice createRandomUtf8Slice(int[] codePointSetint length)
        {
            int[] codePoints = new int[length];
            ThreadLocalRandom random = ThreadLocalRandom.current();
            for (int i = 0; i < codePoints.lengthi++) {
                int codePoint = codePointSet[random.nextInt(codePointSet.length)];
                codePoints[i] = codePoint;
            }
            return utf8Slice(new String(codePoints, 0, codePoints.length));
        }
        public int getLength()
        {
            return ;
        }
        public Slice getLeftWhitespace()
        {
            return ;
        }
        public Slice getRightWhitespace()
        {
            return ;
        }
        public Slice getBothWhitespace()
        {
            return ;
        }
    }
    public static void main(String[] args)
            throws RunnerException
    {
        Options options = new OptionsBuilder()
                .verbosity(.)
                .include(".*" + StringFunctionsBenchmark.class.getSimpleName() + ".*")
                .build();
        new Runner(options).run();
    }
New to GrepCode? Check out our FAQ X