Examples of Pattern

  • jxl.format.Pattern
    Enumeration class which contains the various patterns available within the standard Excel pattern palette
  • net.algart.math.patterns.Pattern
    kipedia.org/wiki/Dilation_%28morphology%29">"Dilation" article in Wikipedia) with a very large pattern, created by {@link Patterns#newMinkowskiSum(java.util.Collection)}and consisting of millions or milliards points, via sequential dilations with the Minkowski summands of such a pattern, extracted by {@link #minkowskiDecomposition(int)} call.

    Coordinate restrictions

    There are the following guarantees for coordinates of the points of any pattern:

    1. if p=(x0,x1,...,xn−1) is some point of the pattern, then − {@link #MAX_COORDINATE}≤xj≤ {@link #MAX_COORDINATE}for all j; here this inequality means absolutely precise mathematical inequality;
    2. if p=(x01,x11,...,xn−11) and q=(x02,x12,...,xn−12) are some two points of the pattern, then |xj1xj2|≤ {@link #MAX_COORDINATE} for all j, where|xj1xj2| means the absolute value of mathematically precise difference (not the result of Java operators Math.abs(xj1xj2)). (This condition can be checked with help of {@link Patterns#isAllowedDifference(double,double)} method.)

    Each implementation of this interface must fulfil both restriction. The point sets, satisfying these requirements, are called allowed points sets for patterns. Any attempt to create a pattern, the set of points of which is not allowed, leads to {@link TooLargePatternCoordinatesException}.

    Note: though patterns are sets of real points, their coordinates are restricted by long-type constant {@link #MAX_COORDINATE}.

    Also note: uniform-grid patterns must fulfil, in addition, two similar restrictions for their grid indexes. See more details in the comments to {@link UniformGridPattern} interface,the section "Grid index restrictions".

    Below are two important theorems, following from these two restrictions.

    Theorem I. If you round the coordinates of all points of a pattern, i.e. replace each pattern's point (x0, x1, ..., xn−1) with a new point (round(x0), round(x1), ..., round(xn−1)), where "round(a)" means the result of (double)StrictMath.round(a) call, then the resulting point set will also be allowed. The same statement is true for the point set, consisting of precise integer points, without type cast to double, i.e. for points (StrictMath.round(x0), StrictMath.round(x1), ..., StrictMath.round(xn−1)) — such mathematical point set also fulfils both restrictions 1 and 2.

    The proof of this is complex enough. The paper http://algart.net/ru/numeric_algorithms/rounding_theorem.html (in Russian) contains such proof: see the theorem of rounding and the theorem of subtraction in this paper.

    It means that you can freely use {@link #round()} method for any pattern:it always constructs another allowed pattern, both in terms of this interface and in terms in {@link UniformGridPattern}, and cannot throw {@link TooLargePatternCoordinatesException}.

    Theorem II. If all points of a pattern are integer, i.e. for all pattern's points (x0, x1, ..., xn−1) we have xj==(double)(long)xj for any index j, and (X0,X1,...,Xn−1) is some point of this pattern, then you can subtract (using Java “−” operator) the coordinate Xj (j is any index) from the corresponding coordinate of all points of this pattern, i.e. replace each pattern's point (x0, ..., xj−1, xj, xj+1, ..., xn−1) with (x0, ..., xj−1, xjXj, xj+1, ..., xn−1), and the resulting point set will also be allowed. Here and below ab (a and b are real values of double Java type) means the computer difference (not strict mathematical), i.e. the result of execution of Java operator “ab”.

    Proof.

    First of all, let's remind that the computer difference ab, according IEEE 754 standard and Java language specification, is the nearest double value to the precise mathematical difference ab. Because all pattern's points are integer, the restriction 2 allows to state that any difference xjXj can be represented precisely by double type (see the comments to {@link #MAX_COORDINATE} constant).So, we have xjXj = xjXj: the computer difference is just a mathematical difference.

    Now the proof is simple. If is enough to show that the restrictions will be satisfied for the coordinate index j. The restriction 2 is obvious: (mathematical) subtracting Xj does not change the (mathematical!) differences |xj1xj2|. The new value of this coordinate for each point will be xjXj, where both (x0,x1,...,xn−1) and (X0,X1,...,Xn−1) are some points of the pattern; according the condition 2, this difference lies in range − {@link #MAX_COORDINATE}≤xjXj≤ {@link #MAX_COORDINATE}. In other words, the restriction 1 is also satisfied. This completes the proof.

    Note: this proof is really correct only for patterns, consisting of integer points only. The reason is that all integer coordinates, fulfilling the restriction 1, and all their differences xjXj are represented precisely by double Java type. If a pattern contains non-integer points, the statement of this theorem is not true. For example, for 1-dimensional pattern, consisting of three points x1=2251799813685248.00 (= {@link #MAX_COORDINATE}/2), x2=−2251799813685248.00 (=− {@link #MAX_COORDINATE}/2) and x3=−2251799813685247.75 (=− {@link #MAX_COORDINATE}/2+0.25), subtracting the point x3 by Java “−” operator leads to the pattern x'1=4503599627370496.00 (= {@link #MAX_COORDINATE}) (computer subtraction of double values leads to rounding here), x'2=−0.25 and x'3=0.0, which obviously violates the mathematically precise restriction 2: |x'1x'2|> {@link #MAX_COORDINATE}.

    As a result, there is an obvious conclusion. If p is one of the {@link #points() points} ofsome integer pattern (see above), then the method pattern. {@link #shift(Point) shift}(p. {@link Point#symmetric() symmetric()}) always works successfully and never throw {@link TooLargePatternCoordinatesException}.

    Note about equals()

    The equals() method in the classes, implementing this interface, may return false for two patterns, consisting of the same point sets, for example, if these patterns belong to different pattern types. For example, a rectangular pattern may be considered to be non-equal to a geometrically identical {@link Patterns#newMinkowskiSum(Pattern) Minkowski sum} of several segments,because the thorough comparison of these patterns can require too long time and large memory. (Please consider 10000x10000x10000 3-dimensional parallelepiped, consisting of 1012 points with integer coordinates in range 0..9999. It is geometrically equal to Minkowski sum of 3 orthogonal segments with 10000 integer points in every segment, but we have no resources to check this fact via direct comparison of the point sets.) However, the patterns of the same kind (for example, two rectangular patterns, two {@link Patterns#newMinkowskiSum(Pattern) Minkowski sums} ortwo {@link Patterns#newUnion(Pattern) unions}) are usually compared precisely. In particular, there are the following guarantees:

    Multithread compatibility

    The classes, implementing this interface, are immutable and thread-safe: there are no ways to modify settings of the created instance.

    AlgART Laboratory 2007–2014

    @author Daniel Alievsky @version 1.2 @since JDK 1.5
  • net.sf.saxon.pattern.Pattern
    A Pattern represents the result of parsing an XSLT pattern string.
    Patterns are created by calling the static method Pattern.make(string).
    The pattern is used to test a particular node by calling match().
  • net.sourceforge.chaperon.model.extended.Pattern
    This class describes an abstract pattern element. @author Stephan Michels @version CVS $Id: Pattern.java,v 1.10 2004/01/08 11:30:52 benedikta Exp $
  • org.apache.camel.Pattern
  • org.apache.geronimo.jee.deployment.Pattern
    3.org/2001/XMLSchema}anyType"> <sequence> <sequence> <element name="groupId" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="artifactId" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="version" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="module" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="type" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="name" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> </sequence> </sequence> </restriction> </complexContent> </complexType> @version $Rev: 688452 $ $Date: 2008-08-24 13:56:20 +0800 (Sun, 24 Aug 2008) $
  • org.apache.geronimo.jee.naming.Pattern
    3.org/2001/XMLSchema}anyType"> <sequence> <element name="groupId" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="artifactId" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="version" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="module" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="name" type="{http://www.w3.org/2001/XMLSchema}string"/> </sequence> </restriction> </complexContent> </complexType> @version $Rev: 704567 $ $Date: 2008-10-14 23:45:57 +0800 (Tue, 14 Oct 2008) $
  • org.apache.geronimo.naming.deployment.jsr88.Pattern
    Holds the elements that make up an ObjectName. This class exists so that the bundle of elements can be get, set, and edited together separate from any other elements that may be on the parent. @version $Rev: 409817 $ $Date: 2006-05-27 09:56:38 +0200 (Sat, 27 May 2006) $
  • org.apache.joran.Pattern
  • org.apache.log4j.joran.spi.Pattern
  • org.apache.mahout.fpm.pfpgrowth.fpgrowth.Pattern
    A in FPGrowth is a list of items (here int) and the support(the number of times the pattern is seen in the dataset)
  • org.apache.marmotta.kiwi.reasoner.model.program.Pattern
    Representation of a graph pattern. A graph pattern has a subject, predicate, and object, and optionally a context. Subject, predicate and object may be either RDF nodes or variables or null. Context is either null or a RDF resource. User: sschaffe
  • org.apache.maven.plugins.enforcer.utils.ArtifactMatcher.Pattern
  • org.apache.myfaces.extensions.validator.baseval.annotation.Pattern
  • org.apache.oro.text.regex.Pattern
    The Pattern interface allows multiple representations of a regular expression to be defined. In general, different regular expression compilers will produce different types of pattern representations. Some will produce state transition tables derived from syntax trees, others will produce byte code representations of an NFA, etc. The Pattern interface does not impose any specific internal pattern representation, and consequently, Pattern implementations are not meant to be interchangeable among differing PatternCompiler and PatternMatcher implementations. The documentation accompanying a specific implementation will define what other classes a Pattern can interact with. @version @version@ @since 1.0 @see PatternCompiler @see PatternMatcher
  • org.apache.servicemix.nmr.api.Pattern
  • org.codehaus.jparsec.pattern.Pattern
    Encapsulates algorithm to recognize certain string pattern. When fed with a character range, a {@link Pattern} object either fails to match, or matches with the match length returned.There is no error reported on where and what exactly failed. @author Ben Yu
  • org.dom4j.rule.Pattern

    Pattern defines the behaviour for pattern in the XSLT processing model.

    @author James Strachan @version $Revision: 1.6 $
  • org.drools.analytics.components.Pattern
    @author Toni Rikkola
  • org.drools.core.rule.Pattern
  • org.drools.planner.examples.nurserostering.domain.Pattern
  • org.drools.rule.Pattern
  • org.drools.verifier.components.Pattern
    @author Toni Rikkola
  • org.eclipse.swt.graphics.Pattern
    ipse.org/swt/snippets/#path">Path, Pattern snippets @see SWT Example: GraphicsExample @see Sample code and further information @since 3.1
  • org.emftrace.metamodel.QUARCModel.GSS.Pattern
  • org.gocha.text.regex.Pattern
    Шаблон (образец текста) производящий сравнение с текстом. Для создания щаблона см. класс Regex @see Regex @author gocha
  • org.gwtwidgets.client.util.regex.Pattern
    oper.mozilla.org/en/docs/Core_JavaScript_1.5_Guide:Regular_Expressions">RegExp object. As most of the methods delegate to the JavaScript RegExp object, certain differences in the declaration and behaviour of regular expressions must be expected.

    Please note that neither the {@link java.util.regex.Pattern#compile(String)} method nor{@link Matcher} instances are supported. For the later, consider using {@link Pattern#match(String)}.

    @author George Georgovassilis
  • org.hibernate.validator.Pattern
  • org.jaxen.pattern.Pattern

    Pattern defines the behaviour for pattern in the XSLT processing model.

    @author James Strachan @version $Revision: 1.4 $
  • org.jboss.bpm.console.client.model.util.regex.Pattern
    oper.mozilla.org/en/docs/Core_JavaScript_1.5_Guide:Regular_Expressions">RegExp object. As most of the methods delegate to the JavaScript RegExp object, certain differences in the declaration and behaviour of regular expressions must be expected.

    Please note that neither the {@link java.util.regex.Pattern#compile(String)} method nor{@link Matcher} instances are supported. For the later, consider using {@link Pattern#match(String)}.

    @author George Georgovassilis
  • org.jboss.bpm.console.client.util.regex.Pattern
    oper.mozilla.org/en/docs/Core_JavaScript_1.5_Guide:Regular_Expressions">RegExp object. As most of the methods delegate to the JavaScript RegExp object, certain differences in the declaration and behaviour of regular expressions must be expected.

    Please note that neither the {@link java.util.regex.Pattern#compile(String)} method nor{@link Matcher} instances are supported. For the later, consider using {@link Pattern#match(String)}.

    @author George Georgovassilis
  • org.jboss.forge.parser.xml.query.Pattern
    A pattern that may be executed as part of a {@link Query} upon a {@link Node} in a search, or used to define a target{@link Node} to be created. Value object analogous to XPath patterns; it describes something in the tree structure of{@link Node}. @author Aslak Knutsen @author Lincoln Baxter, III @author ALR
  • org.jboss.seam.web.Pattern
  • org.jfrog.build.api.dependency.Pattern
    @author jbaruch @since 16/02/12
  • org.jfugue.Pattern
    This class represents a segment of music. By representing segments of music as patterns, JFugue gives users the opportunity to play around with pieces of music in new and interesting ways. Patterns may be added together, transformed, or otherwise manipulated to expand the possibilities of creative music. @author David Koelle @version 2.0 @version 4.0 - Added Pattern Properties @version 4.0.3 - Now implements Serializable
  • org.jregex.Pattern
    A handle for a precompiled regular expression.
    To match a regular expression myExpr against a text myString one should first create a Pattern object:
     Pattern p=new Pattern(myExpr); 
    then obtain a Matcher object:
     Matcher matcher=p.matcher(myText); 
    The latter is an automaton that actually performs a search. It provides the following methods:
  • search for matching substrings : matcher.find() or matcher.findAll();
  • test whether the text matches the whole pattern : matcher.matches();
  • test whether the text matches the beginning of the pattern : matcher.matchesPrefix();
  • search with custom options : matcher.find(int options)

    Flags
    Flags (see REFlags interface) change the meaning of some regular expression elements at compiletime. These flags may be passed both as string(see Pattern(String,String)) and as bitwise OR of:

  • REFlags.IGNORE_CASE - enables case insensitivity
  • REFlags.MULTILINE - forces "^" and "$" to match both at the start and the end of line;
  • REFlags.DOTALL - forces "." to match eols('\r' and '\n' in ASCII);
  • REFlags.IGNORE_SPACES - literal spaces in expression are ignored for better readability;
  • REFlags.UNICODE - the predefined classes('\w','\d',etc) are referenced to Unicode;
  • REFlags.XML_SCHEMA - permits XML Schema regular expressions syntax extentions.

    Multithreading
    Pattern instances are thread-safe, i.e. the same Pattern object may be used by any number of threads simultaniously. On the other hand, the Matcher objects are NOT thread safe, so, given a Pattern instance, each thread must obtain and use its own Matcher. @see REFlags @see Matcher @see Matcher#setTarget(java.lang.String) @see Matcher#setTarget(java.lang.String,int,int) @see Matcher#setTarget(char[],int,int) @see Matcher#setTarget(java.io.Reader,int) @see MatchResult @see MatchResult#group(int) @see MatchResult#start(int) @see MatchResult#end(int) @see MatchResult#length(int) @see MatchResult#charAt(int,int) @see MatchResult#prefix() @see MatchResult#suffix()

  • org.jvnet.glassfish.comms.deployment.backend.Pattern
  • org.kitesdk.morphline.shaded.com.google.code.regexp.Pattern
    A compiled representation of a regular expression. This is a wrapper for the java.util.regex.Pattern with support for named capturing groups. The named groups are specified with "(?<name>exp)", which is identical to Java 7 named groups. @since 0.1.9
  • org.openquark.cal.compiler.SourceModel.Pattern
  • org.optaplanner.examples.nurserostering.domain.pattern.Pattern
  • org.pdf4j.saxon.pattern.Pattern
    A Pattern represents the result of parsing an XSLT pattern string.
    Patterns are created by calling the static method Pattern.make(string).
    The pattern is used to test a particular node by calling match().
  • org.rstudio.core.client.regex.Pattern
  • org.sikuli.script.Pattern
  • org.worldbank.transport.tamt.client.util.Pattern
    oper.mozilla.org/en/docs/Core_JavaScript_1.5_Guide:Regular_Expressions">RegExp object. As most of the methods delegate to the JavaScript RegExp object, certain differences in the declaration and behaviour of regular expressions must be expected.

    Please note that neither the {@link java.util.regex.Pattern#compile(String)} method nor{@link Matcher} instances are supported. For the later, consider using {@link Pattern#match(String)}.

    @author George Georgovassilis
  • ptolemy.actor.gt.Pattern
    @author Thomas Huining Feng @version $Id: Pattern.java,v 1.4.4.1 2008/03/25 22:12:10 cxh Exp $ @since Ptolemy II 6.1 @Pt.ProposedRating Red (tfeng) @Pt.AcceptedRating Red (tfeng)
  • wolf.city.buildings.style.Pattern
  • wyrl.core.Pattern

  • Examples of gnu.javax.swing.text.html.parser.support.low.pattern

      public void testComplexToken()
                            throws Exception
      {
        String x = "< style  >x";

        pattern a =
          new pattern(new node[]
                      {
                        new node(Constants.BEGIN), new node(Constants.NUMTOKEN),
                        new node(Constants.END), new node(Constants.NUMTOKEN)
                      }
                     );

        pattern b =
          new pattern(new node[]
                      {
                        new node(Constants.BEGIN), new node(Constants.STYLE),
                        new node(Constants.END), new node(Constants.NUMTOKEN)
                      }
                     );

        pattern c =
          new pattern(new node[]
                      {
                        new node(Constants.BEGIN), new node(Constants.WS, true),
                        new node(Constants.STYLE), new node(Constants.WS, true),
                        new node(Constants.END), new node(Constants.NUMTOKEN)
                      }
                     );

        pattern d =
          new pattern(new node[]
                      {
                        new node(Constants.BEGIN), new node(Constants.WS, true),
                        new node(Constants.STYLE), new node(Constants.WS, true),
                        new node(Constants.END), new node(Constants.BEGIN)
                      }
                     );

        ReaderTokenizer rt = new ReaderTokenizer();
        rt.reset(new StringReader(x));

        assertFalse(a.matches(rt));
        assertFalse(b.matches(rt));
        assertTrue(c.matches(rt));
        assertFalse(d.matches(rt));
      }
    View Full Code Here

    Examples of it.stefanobertini.zebra.cpcl.labelmode.Pattern

    public class PatternTest {

        @Test
        public void testString() {
      Pattern command = new Pattern("106");

      CommandOutputBuilder output = new CommandOutputBuilder();
      output.printLn("PATTERN 106");

      assertCommand(output, command);
    View Full Code Here

    Examples of java.util.regex.Pattern

          return null;
        }
        String pre = "\\$\\{";
        String post = "\\}";
        String regex = pre+"(.*?)"+post;
        Pattern pattern = Pattern.compile(regex);

        Matcher matcher = pattern.matcher(value);

        while (matcher.find()) {
          String sysKey = matcher.group(1);
          String p = pre + sysKey + post;
          String v = sysKey.equalsIgnoreCase("user.appdata") ? System.getenv("appdata") : System.getProperty(sysKey,"UNKNOWN");
    View Full Code Here

    Examples of java.util.regex.Pattern

            InputStream in = con.getInputStream();

            BufferedReader reader = new BufferedReader(new InputStreamReader(in));

            Matcher matcher;
            Pattern pattern = Pattern.compile("<tr><td>(\\d+):(\\d+)</td><td>(.*?)</td><td>(.*?)</td><td>(.*?)</td></tr>");

            String line = reader.readLine();
            while (line != null) {

                matcher = pattern.matcher(line);
                if (matcher.find()) {
                    // System.out.println("h: "+matcher.group(1)+"; m: "+matcher.group(2)+"; title: "+matcher.group(3)+"; short: "+matcher.group(4)+"; desc: "+matcher.group(5));
                    int h = Integer.parseInt(matcher.group(1));
                    int m = Integer.parseInt(matcher.group(2));
                    String title = matcher.group(3);
    View Full Code Here

    Examples of java.util.regex.Pattern

                    for (Iterator i = appSession.getAttributes().iterator(); i.hasNext();) {
                        String attrName = ((Attribute) i.next()).getName();

                        if (attrName != null) {
                            for (Iterator j = a.iterator(); j.hasNext();) {
                                Pattern p = (Pattern) j.next();
                                if (p.matcher(attrName).matches()) {
                                    j.remove();
                                }
                            }

                            if (a.isEmpty()) {
    View Full Code Here

    Examples of java.util.regex.Pattern

        } catch (NullPointerException e) {
          if (!this.failSilently) throw new IllegalArgumentException(
              "Block '" + blockName + "' not found." +
                  " Matches " + locateBlock(blockName));
        }
        Pattern pattern = Pattern.compile("\\{([\\w\\.]+)\\}");
        Matcher matcher = pattern.matcher(copy);
        pattern = Pattern.compile("_BLOCK_\\.(.+)");
        for (Matcher matcher2; matcher.find();)
        {
          String match = matcher.group(1);
          matcher2 = pattern.matcher(match);
          if (matcher2.find())
          {
            if (parsedBlocks.containsKey(matcher2.group(1)))
            {
              copy = copy.replaceFirst("\\{"+match+"\\}", escape(
    View Full Code Here

    Examples of java.util.regex.Pattern

            .matcher(fileText).matches()) {
          this.implicitMain  = true; // affects parse(block) and out()
          fileText = "<!-- BEGIN: main -->" + fileText + "<!-- END: main -->";
        }
        // END: implicit main
        Pattern pattern = Pattern.compile("<!--\\s*(BEGIN|END)\\s*:\\s*(\\w+)\\s*-->(.*?)(?=(?:<!--\\s*(?:BEGIN|END)\\s*:\\s*\\w+\\s*-->)|(?:\\s*$))", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
        Matcher matcher = pattern.matcher(fileText);
        ArrayList blockNames = new ArrayList();
        String parentName = "";
        int lastlength = 0; // used in newline trimming to see if one block immediately follows the previous
        while (matcher.find())
        {
    View Full Code Here

    Examples of java.util.regex.Pattern

        // Insert leading and trailing characters to ensure match of full string
        rePattern.insert(0, '^');
        rePattern.append('$');

        try {
                Pattern patternRegex = Pattern.compile(rePattern.toString(), Pattern.DOTALL);
                Matcher matcher = patternRegex.matcher(search);
                return matcher.matches();
        } catch(PatternSyntaxException e) {
                throw new ExpressionEvaluationException(e, "ERR.015.006.0014", QueryPlugin.Util.getString("ERR.015.006.0014", new Object[]{pattern, e.getMessage()})); //$NON-NLS-1$ //$NON-NLS-2$
        }
      }
    View Full Code Here

    Examples of java.util.regex.Pattern

    * @author Hans Dockter
    */
    public class SystemPropertiesHandler {
        public static Map<String, String> getSystemProperties(String[] arguments) {
            Map<String, String> propertyMap = new HashMap<String, String>();
            Pattern pattern = Pattern.compile("-D([^=]*)=?(.*)");
            for (String argument : arguments) {
                Matcher matcher = pattern.matcher(argument);
                if (matcher.find()) {
                    String key = matcher.group(1);
                    String value = matcher.group(2);
                    if (key.length() > 0) {
                        propertyMap.put(key, value);
    View Full Code Here

    Examples of java.util.regex.Pattern

                }
            } catch (IOException e) {
                throw new RuntimeException("Error when loading properties file=" + propertiesFile, e);
            }

            Pattern pattern = Pattern.compile("systemProp\\.(.*)");
            for (Object argument : properties.keySet()) {
                Matcher matcher = pattern.matcher(argument.toString());
                if (matcher.find()) {
                    String key = matcher.group(1);
                    if (key.length() > 0) {
                        propertyMap.put(key, properties.get(argument).toString());
                    }
    View Full Code Here
    TOP
    Copyright © 2018 www.massapi.com. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.