content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE is free software: you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation, either version 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * reserved comment block
   * DO NOT REMOVE OR ALTER!
   */
  /*
   * Copyright 1999-2002,2004,2005 The Apache Software Foundation.
   *
   * 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 jaxp.sun.org.apache.xerces.internal.impl.dv.xs;
  
  import jaxp.xml.datatype.DatatypeConstants;
  import jaxp.xml.datatype.XMLGregorianCalendar;
  
  import jaxp.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException;
  import jaxp.sun.org.apache.xerces.internal.impl.dv.ValidationContext;
  
  /**
   * Validator for &lt;gYear&gt; datatype (W3C Schema Datatypes)
   *
   * @xerces.internal
   *
   * @author Elena Litani
   * @author Gopal Sharma, SUN Microsystem Inc.
   *
   * @version $Id: YearDV.java,v 1.7 2010-11-01 04:39:47 joehw Exp $
   */
  
  public class YearDV extends AbstractDateTimeDV {
  
      /**
       * Convert a string to a compiled form
       *
       * @param  content The lexical representation of time
       * @return a valid and normalized time object
       */
      public Object getActualValue(String content, ValidationContext context) throws InvalidDatatypeValueException {
          try{
              return parse(content);
          } catch(Exception ex){
              throw new InvalidDatatypeValueException("cvc-datatype-valid.1.2.1", new Object[]{content, "gYear"});
          }
      }
  
      /**
       * Parses, validates and computes normalized version of gYear object
       *
       * @param str    The lexical representation of year object CCYY
       *               with possible time zone Z or (-),(+)hh:mm
       * @return normalized date representation
       * @exception SchemaDateTimeException Invalid lexical representation
       */
      protected DateTimeData parse(String str) throws SchemaDateTimeException{
          DateTimeData date = new DateTimeData(str, this);
          int len = str.length();
  
          // check for preceding '-' sign
          int start = 0;
          if (str.charAt(0)=='-') {
              start = 1;
          }
          int sign = findUTCSign(str, start, len);
  
          final int length = ((sign == -1) ? len : sign) - start;
          if (length < 4) {
              throw new RuntimeException("Year must have 'CCYY' format");
          }
          else if (length > 4 && str.charAt(start) == '0') {
              throw new RuntimeException("Leading zeros are required if the year value would otherwise have fewer than four digits; otherwise they are forbidden");
          }
  
          if (sign == -1) {
              date.year=parseIntYear(str, len);
          }
          else {
              date.year=parseIntYear(str, sign);
              getTimeZone (str, date, sign, len);
          }
  
          //initialize values
          date.month=MONTH;
          date.day=1;
  
          //validate and normalize
          validateDateTime(date);
  
          //save unnormalized values
          saveUnnormalized(date);
  
          if ( date.utc!=0 && date.utc!='Z' ) {
              normalize(date);
          }
          date.position = 0;
          return date;
      }
  
      /**
       * Converts year object representation to String
       *
       * @param date   year object
       * @return lexical representation of month: CCYY with optional time zone sign
       */
      protected String dateToString(DateTimeData date) {
          StringBuffer message = new StringBuffer(5);
          append(message, date.year, 4);
          append(message, (char)date.utc, 0);
          return message.toString();
      }
  
      protected XMLGregorianCalendar getXMLGregorianCalendar(DateTimeData date) {
          return datatypeFactory.newXMLGregorianCalendar(date.unNormYear, DatatypeConstants.FIELD_UNDEFINED,
                  DatatypeConstants.FIELD_UNDEFINED, DatatypeConstants.FIELD_UNDEFINED, DatatypeConstants.FIELD_UNDEFINED,
                  DatatypeConstants.FIELD_UNDEFINED, DatatypeConstants.FIELD_UNDEFINED,
                  date.hasTimeZone() ? date.timezoneHr * 60 + date.timezoneMin : DatatypeConstants.FIELD_UNDEFINED);
      }
  }
  