1 /*
   2  * Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package javax.print;
  27 
  28 import java.io.Serializable;
  29 
  30 import java.util.AbstractMap;
  31 import java.util.AbstractSet;
  32 import java.util.Iterator;
  33 import java.util.Map;
  34 import java.util.NoSuchElementException;
  35 import java.util.Set;
  36 import java.util.Vector;
  37 
  38 /**
  39  * Class MimeType encapsulates a Multipurpose Internet Mail Extensions (MIME)
  40  * media type as defined in <A HREF="http://www.ietf.org/rfc/rfc2045.txt">RFC
  41  * 2045</A> and <A HREF="http://www.ietf.org/rfc/rfc2046.txt">RFC 2046</A>. A
  42  * MIME type object is part of a {@link DocFlavor DocFlavor} object and
  43  * specifies the format of the print data.
  44  * <P>
  45  * Class MimeType is similar to the like-named
  46  * class in package {@link java.awt.datatransfer java.awt.datatransfer}. Class
  47  * java.awt.datatransfer.MimeType is not used in the Jini Print Service API
  48  * for two reasons:
  49  * <OL TYPE=1>
  50  * <LI>
  51  * Since not all Java profiles include the AWT, the Jini Print Service should
  52  * not depend on an AWT class.
  53  * <P>
  54  * <LI>
  55  * The implementation of class java.awt.datatransfer.MimeType does not
  56  * guarantee
  57  * that equivalent MIME types will have the same serialized representation.
  58  * Thus, since the Jini Lookup Service (JLUS) matches service attributes based
  59  * on equality of serialized representations, JLUS searches involving MIME
  60  * types encapsulated in class java.awt.datatransfer.MimeType may incorrectly
  61  * fail to match.
  62  * </OL>
  63  * <P>
  64  * Class MimeType's serialized representation is based on the following
  65  * canonical form of a MIME type string. Thus, two MIME types that are not
  66  * identical but that are equivalent (that have the same canonical form) will
  67  * be considered equal by the JLUS's matching algorithm.
  68  * <UL>
  69  * <LI> The media type, media subtype, and parameters are retained, but all
  70  *      comments and whitespace characters are discarded.
  71  * <LI> The media type, media subtype, and parameter names are converted to
  72  *      lowercase.
  73  * <LI> The parameter values retain their original case, except a charset
  74  *      parameter value for a text media type is converted to lowercase.
  75  * <LI> Quote characters surrounding parameter values are removed.
  76  * <LI> Quoting backslash characters inside parameter values are removed.
  77  * <LI> The parameters are arranged in ascending order of parameter name.
  78  * </UL>
  79  * <P>
  80  *
  81  * @author  Alan Kaminsky
  82  */
  83 class MimeType implements Serializable, Cloneable {
  84 
  85     private static final long serialVersionUID = -2785720609362367683L;
  86 
  87     /**
  88      * Array of strings that hold pieces of this MIME type's canonical form.
  89      * If the MIME type has <I>n</I> parameters, <I>n</I> &gt;= 0, then the
  90      * strings in the array are:
  91      * <BR>Index 0 -- Media type.
  92      * <BR>Index 1 -- Media subtype.
  93      * <BR>Index 2<I>i</I>+2 -- Name of parameter <I>i</I>,
  94      * <I>i</I>=0,1,...,<I>n</I>-1.
  95      * <BR>Index 2<I>i</I>+3 -- Value of parameter <I>i</I>,
  96      * <I>i</I>=0,1,...,<I>n</I>-1.
  97      * <BR>Parameters are arranged in ascending order of parameter name.
  98      * @serial
  99      */
 100     private String[] myPieces;
 101 
 102     /**
 103      * String value for this MIME type. Computed when needed and cached.
 104      */
 105     private transient String myStringValue = null;
 106 
 107     /**
 108      * Parameter map entry set. Computed when needed and cached.
 109      */
 110     private transient ParameterMapEntrySet myEntrySet = null;
 111 
 112     /**
 113      * Parameter map. Computed when needed and cached.
 114      */
 115     private transient ParameterMap myParameterMap = null;
 116 
 117     /**
 118      * Parameter map entry.
 119      */
 120     private class ParameterMapEntry implements Map.Entry {
 121         private int myIndex;
 122         public ParameterMapEntry(int theIndex) {
 123             myIndex = theIndex;
 124         }
 125         public Object getKey(){
 126             return myPieces[myIndex];
 127         }
 128         public Object getValue(){
 129             return myPieces[myIndex+1];
 130         }
 131         public Object setValue (Object value) {
 132             throw new UnsupportedOperationException();
 133         }
 134         public boolean equals(Object o) {
 135             return (o != null &&
 136                     o instanceof Map.Entry &&
 137                     getKey().equals (((Map.Entry) o).getKey()) &&
 138                     getValue().equals(((Map.Entry) o).getValue()));
 139         }
 140         public int hashCode() {
 141             return getKey().hashCode() ^ getValue().hashCode();
 142         }
 143     }
 144 
 145     /**
 146      * Parameter map entry set iterator.
 147      */
 148     private class ParameterMapEntrySetIterator implements Iterator {
 149         private int myIndex = 2;
 150         public boolean hasNext() {
 151             return myIndex < myPieces.length;
 152         }
 153         public Object next() {
 154             if (hasNext()) {
 155                 ParameterMapEntry result = new ParameterMapEntry (myIndex);
 156                 myIndex += 2;
 157                 return result;
 158             } else {
 159                 throw new NoSuchElementException();
 160             }
 161         }
 162         public void remove() {
 163             throw new UnsupportedOperationException();
 164         }
 165     }
 166 
 167     /**
 168      * Parameter map entry set.
 169      */
 170     private class ParameterMapEntrySet extends AbstractSet {
 171         public Iterator iterator() {
 172             return new ParameterMapEntrySetIterator();
 173         }
 174         public int size() {
 175             return (myPieces.length - 2) / 2;
 176         }
 177     }
 178 
 179     /**
 180      * Parameter map.
 181      */
 182     private class ParameterMap extends AbstractMap {
 183         public Set entrySet() {
 184             if (myEntrySet == null) {
 185                 myEntrySet = new ParameterMapEntrySet();
 186             }
 187             return myEntrySet;
 188         }
 189     }
 190 
 191     /**
 192      * Construct a new MIME type object from the given string. The given
 193      * string is converted into canonical form and stored internally.
 194      *
 195      * @param  s  MIME media type string.
 196      *
 197      * @exception  NullPointerException
 198      *     (unchecked exception) Thrown if <CODE>s</CODE> is null.
 199      * @exception  IllegalArgumentException
 200      *     (unchecked exception) Thrown if <CODE>s</CODE> does not obey the
 201      *     syntax for a MIME media type string.
 202      */
 203     public MimeType(String s) {
 204         parse (s);
 205     }
 206 
 207     /**
 208      * Returns this MIME type object's MIME type string based on the canonical
 209      * form. Each parameter value is enclosed in quotes.
 210      */
 211     public String getMimeType() {
 212         return getStringValue();
 213     }
 214 
 215     /**
 216      * Returns this MIME type object's media type.
 217      */
 218     public String getMediaType() {
 219         return myPieces[0];
 220     }
 221 
 222     /**
 223      * Returns this MIME type object's media subtype.
 224      */
 225     public String getMediaSubtype() {
 226         return myPieces[1];
 227     }
 228 
 229     /**
 230      * Returns an unmodifiable map view of the parameters in this MIME type
 231      * object. Each entry in the parameter map view consists of a parameter
 232      * name String (key) mapping to a parameter value String. If this MIME
 233      * type object has no parameters, an empty map is returned.
 234      *
 235      * @return  Parameter map for this MIME type object.
 236      */
 237     public Map getParameterMap() {
 238         if (myParameterMap == null) {
 239             myParameterMap = new ParameterMap();
 240         }
 241         return myParameterMap;
 242     }
 243 
 244     /**
 245      * Converts this MIME type object to a string.
 246      *
 247      * @return  MIME type string based on the canonical form. Each parameter
 248      *          value is enclosed in quotes.
 249      */
 250     public String toString() {
 251         return getStringValue();
 252     }
 253 
 254     /**
 255      * Returns a hash code for this MIME type object.
 256      */
 257     public int hashCode() {
 258         return getStringValue().hashCode();
 259     }
 260 
 261     /**
 262      * Determine if this MIME type object is equal to the given object. The two
 263      * are equal if the given object is not null, is an instance of class
 264      * net.jini.print.data.MimeType, and has the same canonical form as this
 265      * MIME type object (that is, has the same type, subtype, and parameters).
 266      * Thus, if two MIME type objects are the same except for comments, they are
 267      * considered equal. However, "text/plain" and "text/plain;
 268      * charset=us-ascii" are not considered equal, even though they represent
 269      * the same media type (because the default character set for plain text is
 270      * US-ASCII).
 271      *
 272      * @param  obj  Object to test.
 273      *
 274      * @return  True if this MIME type object equals <CODE>obj</CODE>, false
 275      *          otherwise.
 276      */
 277     public boolean equals (Object obj) {
 278         return(obj != null &&
 279                obj instanceof MimeType &&
 280                getStringValue().equals(((MimeType) obj).getStringValue()));
 281     }
 282 
 283     /**
 284      * Returns this MIME type's string value in canonical form.
 285      */
 286     private String getStringValue() {
 287         if (myStringValue == null) {
 288             StringBuffer result = new StringBuffer();
 289             result.append (myPieces[0]);
 290             result.append ('/');
 291             result.append (myPieces[1]);
 292             int n = myPieces.length;
 293             for (int i = 2; i < n; i += 2) {
 294                 result.append(';');
 295                 result.append(' ');
 296                 result.append(myPieces[i]);
 297                 result.append('=');
 298                 result.append(addQuotes (myPieces[i+1]));
 299             }
 300             myStringValue = result.toString();
 301         }
 302         return myStringValue;
 303     }
 304 
 305 // Hidden classes, constants, and operations for parsing a MIME media type
 306 // string.
 307 
 308     // Lexeme types.
 309     private static final int TOKEN_LEXEME         = 0;
 310     private static final int QUOTED_STRING_LEXEME = 1;
 311     private static final int TSPECIAL_LEXEME      = 2;
 312     private static final int EOF_LEXEME           = 3;
 313     private static final int ILLEGAL_LEXEME       = 4;
 314 
 315     // Class for a lexical analyzer.
 316     private static class LexicalAnalyzer {
 317         protected String mySource;
 318         protected int mySourceLength;
 319         protected int myCurrentIndex;
 320         protected int myLexemeType;
 321         protected int myLexemeBeginIndex;
 322         protected int myLexemeEndIndex;
 323 
 324         public LexicalAnalyzer(String theSource) {
 325             mySource = theSource;
 326             mySourceLength = theSource.length();
 327             myCurrentIndex = 0;
 328             nextLexeme();
 329         }
 330 
 331         public int getLexemeType() {
 332             return myLexemeType;
 333         }
 334 
 335         public String getLexeme() {
 336             return(myLexemeBeginIndex >= mySourceLength ?
 337                    null :
 338                    mySource.substring(myLexemeBeginIndex, myLexemeEndIndex));
 339         }
 340 
 341         public char getLexemeFirstCharacter() {
 342             return(myLexemeBeginIndex >= mySourceLength ?
 343                    '\u0000' :
 344                    mySource.charAt(myLexemeBeginIndex));
 345         }
 346 
 347         public void nextLexeme() {
 348             int state = 0;
 349             int commentLevel = 0;
 350             char c;
 351             while (state >= 0) {
 352                 switch (state) {
 353                     // Looking for a token, quoted string, or tspecial
 354                 case 0:
 355                     if (myCurrentIndex >= mySourceLength) {
 356                         myLexemeType = EOF_LEXEME;
 357                         myLexemeBeginIndex = mySourceLength;
 358                         myLexemeEndIndex = mySourceLength;
 359                         state = -1;
 360                     } else if (Character.isWhitespace
 361                                (c = mySource.charAt (myCurrentIndex ++))) {
 362                         state = 0;
 363                     } else if (c == '\"') {
 364                         myLexemeType = QUOTED_STRING_LEXEME;
 365                         myLexemeBeginIndex = myCurrentIndex;
 366                         state = 1;
 367                     } else if (c == '(') {
 368                         ++ commentLevel;
 369                         state = 3;
 370                     } else if (c == '/'  || c == ';' || c == '=' ||
 371                                c == ')'  || c == '<' || c == '>' ||
 372                                c == '@'  || c == ',' || c == ':' ||
 373                                c == '\\' || c == '[' || c == ']' ||
 374                                c == '?') {
 375                         myLexemeType = TSPECIAL_LEXEME;
 376                         myLexemeBeginIndex = myCurrentIndex - 1;
 377                         myLexemeEndIndex = myCurrentIndex;
 378                         state = -1;
 379                     } else {
 380                         myLexemeType = TOKEN_LEXEME;
 381                         myLexemeBeginIndex = myCurrentIndex - 1;
 382                         state = 5;
 383                     }
 384                     break;
 385                     // In a quoted string
 386                 case 1:
 387                     if (myCurrentIndex >= mySourceLength) {
 388                         myLexemeType = ILLEGAL_LEXEME;
 389                         myLexemeBeginIndex = mySourceLength;
 390                         myLexemeEndIndex = mySourceLength;
 391                         state = -1;
 392                     } else if ((c = mySource.charAt (myCurrentIndex ++)) == '\"') {
 393                         myLexemeEndIndex = myCurrentIndex - 1;
 394                         state = -1;
 395                     } else if (c == '\\') {
 396                         state = 2;
 397                     } else {
 398                         state = 1;
 399                     }
 400                     break;
 401                     // In a quoted string, backslash seen
 402                 case 2:
 403                     if (myCurrentIndex >= mySourceLength) {
 404                         myLexemeType = ILLEGAL_LEXEME;
 405                         myLexemeBeginIndex = mySourceLength;
 406                         myLexemeEndIndex = mySourceLength;
 407                         state = -1;
 408                     } else {
 409                         ++ myCurrentIndex;
 410                         state = 1;
 411                     } break;
 412                     // In a comment
 413                 case 3: if (myCurrentIndex >= mySourceLength) {
 414                     myLexemeType = ILLEGAL_LEXEME;
 415                     myLexemeBeginIndex = mySourceLength;
 416                     myLexemeEndIndex = mySourceLength;
 417                     state = -1;
 418                 } else if ((c = mySource.charAt (myCurrentIndex ++)) == '(') {
 419                     ++ commentLevel;
 420                     state = 3;
 421                 } else if (c == ')') {
 422                     -- commentLevel;
 423                     state = commentLevel == 0 ? 0 : 3;
 424                 } else if (c == '\\') {
 425                     state = 4;
 426                 } else { state = 3;
 427                 }
 428                 break;
 429                 // In a comment, backslash seen
 430                 case 4:
 431                     if (myCurrentIndex >= mySourceLength) {
 432                         myLexemeType = ILLEGAL_LEXEME;
 433                         myLexemeBeginIndex = mySourceLength;
 434                         myLexemeEndIndex = mySourceLength;
 435                         state = -1;
 436                     } else {
 437                         ++ myCurrentIndex;
 438                         state = 3;
 439                     }
 440                     break;
 441                     // In a token
 442                 case 5:
 443                     if (myCurrentIndex >= mySourceLength) {
 444                         myLexemeEndIndex = myCurrentIndex;
 445                         state = -1;
 446                     } else if (Character.isWhitespace
 447                                (c = mySource.charAt (myCurrentIndex ++))) {
 448                         myLexemeEndIndex = myCurrentIndex - 1;
 449                         state = -1;
 450                     } else if (c == '\"' || c == '(' || c == '/' ||
 451                                c == ';'  || c == '=' || c == ')' ||
 452                                c == '<' || c == '>'  || c == '@' ||
 453                                c == ',' || c == ':' || c == '\\' ||
 454                                c == '[' || c == ']' || c == '?') {
 455                         -- myCurrentIndex;
 456                         myLexemeEndIndex = myCurrentIndex;
 457                         state = -1;
 458                     } else {
 459                         state = 5;
 460                     }
 461                     break;
 462                 }
 463             }
 464 
 465         }
 466 
 467     }
 468 
 469     /**
 470      * Returns a lowercase version of the given string. The lowercase version
 471      * is constructed by applying Character.toLowerCase() to each character of
 472      * the given string, which maps characters to lowercase using the rules of
 473      * Unicode. This mapping is the same regardless of locale, whereas the
 474      * mapping of String.toLowerCase() may be different depending on the
 475      * default locale.
 476      */
 477     private static String toUnicodeLowerCase(String s) {
 478         int n = s.length();
 479         char[] result = new char [n];
 480         for (int i = 0; i < n; ++ i) {
 481             result[i] = Character.toLowerCase (s.charAt (i));
 482         }
 483         return new String (result);
 484     }
 485 
 486     /**
 487      * Returns a version of the given string with backslashes removed.
 488      */
 489     private static String removeBackslashes(String s) {
 490         int n = s.length();
 491         char[] result = new char [n];
 492         int i;
 493         int j = 0;
 494         char c;
 495         for (i = 0; i < n; ++ i) {
 496             c = s.charAt (i);
 497             if (c == '\\') {
 498                 c = s.charAt (++ i);
 499             }
 500             result[j++] = c;
 501         }
 502         return new String (result, 0, j);
 503     }
 504 
 505     /**
 506      * Returns a version of the string surrounded by quotes and with interior
 507      * quotes preceded by a backslash.
 508      */
 509     private static String addQuotes(String s) {
 510         int n = s.length();
 511         int i;
 512         char c;
 513         StringBuffer result = new StringBuffer (n+2);
 514         result.append ('\"');
 515         for (i = 0; i < n; ++ i) {
 516             c = s.charAt (i);
 517             if (c == '\"') {
 518                 result.append ('\\');
 519             }
 520             result.append (c);
 521         }
 522         result.append ('\"');
 523         return result.toString();
 524     }
 525 
 526     /**
 527      * Parses the given string into canonical pieces and stores the pieces in
 528      * {@link #myPieces <CODE>myPieces</CODE>}.
 529      * <P>
 530      * Special rules applied:
 531      * <UL>
 532      * <LI> If the media type is text, the value of a charset parameter is
 533      *      converted to lowercase.
 534      * </UL>
 535      *
 536      * @param  s  MIME media type string.
 537      *
 538      * @exception  NullPointerException
 539      *     (unchecked exception) Thrown if <CODE>s</CODE> is null.
 540      * @exception  IllegalArgumentException
 541      *     (unchecked exception) Thrown if <CODE>s</CODE> does not obey the
 542      *     syntax for a MIME media type string.
 543      */
 544     private void parse(String s) {
 545         // Initialize.
 546         if (s == null) {
 547             throw new NullPointerException();
 548         }
 549         LexicalAnalyzer theLexer = new LexicalAnalyzer (s);
 550         int theLexemeType;
 551         Vector thePieces = new Vector();
 552         boolean mediaTypeIsText = false;
 553         boolean parameterNameIsCharset = false;
 554 
 555         // Parse media type.
 556         if (theLexer.getLexemeType() == TOKEN_LEXEME) {
 557             String mt = toUnicodeLowerCase (theLexer.getLexeme());
 558             thePieces.add (mt);
 559             theLexer.nextLexeme();
 560             mediaTypeIsText = mt.equals ("text");
 561         } else {
 562             throw new IllegalArgumentException();
 563         }
 564         // Parse slash.
 565         if (theLexer.getLexemeType() == TSPECIAL_LEXEME &&
 566               theLexer.getLexemeFirstCharacter() == '/') {
 567             theLexer.nextLexeme();
 568         } else {
 569             throw new IllegalArgumentException();
 570         }
 571         if (theLexer.getLexemeType() == TOKEN_LEXEME) {
 572             thePieces.add (toUnicodeLowerCase (theLexer.getLexeme()));
 573             theLexer.nextLexeme();
 574         } else {
 575             throw new IllegalArgumentException();
 576         }
 577         // Parse zero or more parameters.
 578         while (theLexer.getLexemeType() == TSPECIAL_LEXEME &&
 579                theLexer.getLexemeFirstCharacter() == ';') {
 580             // Parse semicolon.
 581             theLexer.nextLexeme();
 582 
 583             // Parse parameter name.
 584             if (theLexer.getLexemeType() == TOKEN_LEXEME) {
 585                 String pn = toUnicodeLowerCase (theLexer.getLexeme());
 586                 thePieces.add (pn);
 587                 theLexer.nextLexeme();
 588                 parameterNameIsCharset = pn.equals ("charset");
 589             } else {
 590                 throw new IllegalArgumentException();
 591             }
 592 
 593             // Parse equals.
 594             if (theLexer.getLexemeType() == TSPECIAL_LEXEME &&
 595                 theLexer.getLexemeFirstCharacter() == '=') {
 596                 theLexer.nextLexeme();
 597             } else {
 598                 throw new IllegalArgumentException();
 599             }
 600 
 601             // Parse parameter value.
 602             if (theLexer.getLexemeType() == TOKEN_LEXEME) {
 603                 String pv = theLexer.getLexeme();
 604                 thePieces.add(mediaTypeIsText && parameterNameIsCharset ?
 605                               toUnicodeLowerCase (pv) :
 606                               pv);
 607                 theLexer.nextLexeme();
 608             } else if (theLexer.getLexemeType() == QUOTED_STRING_LEXEME) {
 609                 String pv = removeBackslashes (theLexer.getLexeme());
 610                 thePieces.add(mediaTypeIsText && parameterNameIsCharset ?
 611                               toUnicodeLowerCase (pv) :
 612                               pv);
 613                 theLexer.nextLexeme();
 614             } else {
 615                 throw new IllegalArgumentException();
 616             }
 617         }
 618 
 619         // Make sure we've consumed everything.
 620         if (theLexer.getLexemeType() != EOF_LEXEME) {
 621             throw new IllegalArgumentException();
 622         }
 623 
 624         // Save the pieces. Parameters are not in ascending order yet.
 625         int n = thePieces.size();
 626         myPieces = (String[]) thePieces.toArray (new String [n]);
 627 
 628         // Sort the parameters into ascending order using an insertion sort.
 629         int i, j;
 630         String temp;
 631         for (i = 4; i < n; i += 2) {
 632             j = 2;
 633             while (j < i && myPieces[j].compareTo (myPieces[i]) <= 0) {
 634                 j += 2;
 635             }
 636             while (j < i) {
 637                 temp = myPieces[j];
 638                 myPieces[j] = myPieces[i];
 639                 myPieces[i] = temp;
 640                 temp = myPieces[j+1];
 641                 myPieces[j+1] = myPieces[i+1];
 642                 myPieces[i+1] = temp;
 643                 j += 2;
 644             }
 645         }
 646     }
 647 }
--- EOF ---