(file) Return to LanguageParser.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/LanguageParser.h between version 1.8 and 1.18

version 1.8, 2005/02/05 22:59:23 version 1.18, 2006/01/10 19:41:15
Line 29 
Line 29 
 // //
 // Author: Humberto Rivero (hurivero@us.ibm.com) // Author: Humberto Rivero (hurivero@us.ibm.com)
 // //
 // Modified By:  // Modified By: Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3697, 3698, 3699, 3700
   //              Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3701, 3702, 3703
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 42 
Line 44 
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/String.h> #include <Pegasus/Common/String.h>
 #include <Pegasus/Common/Array.h> #include <Pegasus/Common/Array.h>
   #include <Pegasus/Common/AcceptLanguageList.h>
 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES  #include <Pegasus/Common/ContentLanguageList.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   /**
 /** This class parses and validates AcceptLanguage OR ContentLanguage values      This class parses and validates Accept-Language and Content-Language values
  * from the respective HTTP headers, and provides various utility functions      from the respective HTTP headers, and provides utility functions to parse
  * to parse and manipulate language information      and manipulate language information
  */  */
 class PEGASUS_COMMON_LINKAGE LanguageParser{  class PEGASUS_COMMON_LINKAGE LanguageParser
   {
 public: public:
  
 /**     This member is used to represent an empty LanguageParser. Using this      /**
     member avoids construction of an empty LanguageParser          Builds an AcceptLanguageList object from an HTTP Accept-Language
     (e.g., LanguageParser()).          header value.
 */          @param acceptLanguageHeader A String containing an HTTP
 static const LanguageParser EMPTY;          Accept-Language header value from which to build the AcceptLanguageList
           object.
 /** Parses the value portion of either an AcceptLanguage HTTP header or a          @exception InvalidAcceptLanguageHeader if a syntax error is
  * ContentLanguage HTTP header, extracts the individual fields and stores          encountered.
  * them in an array.  
  * @param values Array<String>& where the individual fields are stored  
  * @param hdr String the value portion of the HTTP Accept/ContentLanguage header  
  */  */
 void parseHdr(Array<String> &values, String & hdr);      static AcceptLanguageList parseAcceptLanguageHeader(
           const String& acceptLanguageHeader);
  
 /** Parses an AcceptLanguage or ContentLanguage value from a header.      /**
  * If a valid AcceptLanguage value is determined to contain a quality          Builds a ContentLanguageList object from an HTTP Content-Language
  * value, then this quality once validated is returned. Otherwise -1 is returned.          header value.
  * It is up to the caller to know in what context this call is being made,          @param contentLanguageHeader A String containing an HTTP
  * that is: it is the callers responsibility to know whether          Content-Language header value from which to build the
  * an AcceptLanguage or a ContentLanguage value is being parsed.          ContentLanguageList object.
  * @param language String& where the valid language is stored          @exception InvalidContentLanguageHeader if a syntax error is
  * @param hdr String the value being parsed and validated          encountered.
  * @return Real32 if a valid quality found then 1 <=> 0, otherwise 1  
  * @exception throws ???  
  */  */
 Real32 parseAcceptLanguageValue(String &language, String & hdr);      static ContentLanguageList parseContentLanguageHeader(
           const String& contentLanguageHeader);
  
 String parseContentLanguageValue(String & hdr);      /**
           Validates the syntax of a language tag according to RFC 3066.
           Parses the language tag into language, country, and variant, if
           the language tag is formed using ISO codes (ISO 639 and ISO 3166).
           @param languageTagString The language tag string to parse and
           validate.
           @param language The returned language value parsed from the language
           tag, if applicable.
           @param country The returned country value parsed from the language
           tag, if applicable.
           @param variant The returned language variant value parsed from the
           language tag, if applicable.
           @exception Exception if the language tag is syntactically invalid.
        */
       static void parseLanguageTag(
           const String& languageTagString,
           String& language,
           String& country,
           String& variant);
  
 /** /**
  * Given a language ex: en-US-xx,          Validates the syntax of an Accept-Language quality value.
  * returns the base of the language "en".          @param quality A Real32 quality value to validate.
  * @param language String          @exception Exception if the quality value is invalid.
  * @param separator Char16 the character that separates the various subtags  
  * @return String base of the language parameter  
  */  */
 String getLanguage(String & language_tag);      static void validateQualityValue(Real32 quality);
   
 String getCountry(String & language_tag);  
   
 String getVariant(String & language_tag);  
   
 private:  
  
 /** /**
  * Fills the first position in the array with the most general part of          Builds an HTTP Accept-Language header value from an AcceptLanguageList
  * the language String, each subsequent postion is the array gets more          object.
  * and more detailed.  For example: en-us-fooblah would be returned as          @param acceptLanguages The AcceptLanguageList object to be encoded in
  * ["en"]["us"]["fooblah"]          an HTTP Accept-Language header.
  * @param subtags Array<String>& array filled in with the root and subtags  
  * @param language String the language to parse  
  * @param separator Char16 the character that separates the various subtags  
  * @return String the root of the language tag  
  */  */
 void parseLanguageSubtags(Array<String> &subtags, String language_tag);      static String buildAcceptLanguageHeader(
           const AcceptLanguageList& acceptLanguages);
  
 /** Breaks the language into its parts(subtags), then validates each part      /**
  * according to the RFCs.          Builds an HTTP Content-Language header value from a ContentLanguageList
  * @param s String language to be validated          object.
  * @return Boolean          @param contentLanguages The ContentLanguageList object to be encoded
           in an HTTP Content-Language header.
  */  */
 Boolean isValid(String language_tag, Boolean length_check = true);      static String buildContentLanguageHeader(
           const ContentLanguageList& contentLanguages);
  
 /** Checks if the String has all characters in A-Z OR a-z range.      /**
  * @param s String          Returns the default accept languages based on environment settings.
  * @return Boolean          ATTN: What is the behavior?  This is only implemented if MESSAGES and
           ICU are used.
  */  */
 Boolean checkAlpha(CString _str);      static AcceptLanguageList getDefaultAcceptLanguages();
  
 CString replaceSeparator(CString _s, char new_sep = '-');  private:
  
 char findSeparator(CString _str);      /**
           Parses the value portion of an HTTP Accept-Language or Content-Language
           header into individual language elements.  Comments and whitespace are
           removed.
           @param headerElements An array of Strings into which the language
           elements are stored.
           @param languageHeaderValue A String containing the value portion of
           an HTTP Accept-Language or Content-Language header.
           @exception Exception if a syntax error is encountered.
        */
       static void _parseLanguageHeader(
           const String& languageHeaderValue,
           Array<String>& languageElements);
  
 String convertPrivateLanguageTag(String language_tag);      /**
           Parses an AcceptLanguage or ContentLanguage value from a header.
           If a valid AcceptLanguage value is determined to contain a quality
           value, then this quality is validated and returned. Otherwise -1 is
           returned.  It is up to the caller to know in what context this call
           is being made, that is: it is the callers responsibility to know
           whether an AcceptLanguage or a ContentLanguage value is being parsed.
           @param acceptLanguageHeaderElement String to be parsed into a
           language tag and quality value.  The String must not contain comments
           or whitespace.
           @param languageTag String into which the parsed language tag is
           stored.
           @param quality Real32 into which the parsed quality value is stored.
           @exception Exception if a syntax error is encountered.
        */
       static void _parseAcceptLanguageElement(
           const String& acceptLanguageElement,
           String& languageTag,
           Real32& quality);
  
 }; //end LanguageParser      /**
           Fills the first position in the array with the most general part of
           the language String, each subsequent postion is the array gets more
           and more detailed.  For example: en-us-fooblah would be returned as
           ["en"]["us"]["fooblah"]
           @param subtags Array<String>& array filled in with the root and subtags
           @param languageTag String the language to parse
           @return String the root of the language tag
           @exception Exception if a syntax error is encountered.
        */
       static void _parseLanguageSubtags(
           Array<String>& subtags,
           const String& languageTagString);
  
 PEGASUS_NAMESPACE_END      /**
           Checks if a String represents a valid language tag primary subtag.
           A valid primary subtag contains 1 to 8 alphabetic characters.
           @param subtag The subtag String to validate.
           @return True if the String represents a valid language tag primary
           subtag; false otherwise.
        */
       static Boolean _isValidPrimarySubtagSyntax(const String& subtag);
   
       /**
           Checks if a String represents a valid language tag subtag.
           A valid primary subtag contains 1 to 8 alphanumeric characters.
           @param subtag The subtag String to validate.
           @return True if the String represents a valid language tag subtag;
           false otherwise.
        */
       static Boolean _isValidSubtagSyntax(const String& subtag);
   };
  
 #endif  // PEGASUS_USE_EXPERIMENTAL_INTERFACES  PEGASUS_NAMESPACE_END
  
 #endif #endif

Legend:
Removed from v.1.8  
changed lines
  Added in v.1.18
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2