jackcess/src/main/java/com/healthmarketscience/jackcess/impl/expr/StringValue.java

/*
Copyright (c) 2016 James Ahlborn

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.healthmarketscience.jackcess.impl.expr;

import java.math.BigDecimal;
import java.text.DecimalFormatSymbols;

import com.healthmarketscience.jackcess.expr.EvalException;
import com.healthmarketscience.jackcess.expr.LocaleContext;
import com.healthmarketscience.jackcess.expr.Value;
import org.apache.commons.lang3.StringUtils;

/**
 *
 * @author James Ahlborn
 */
public class StringValue extends BaseValue
{
  private static final Object NOT_A_NUMBER = new Object();

  private final String _val;
  private Object _num;

  public StringValue(String val)
  {
    _val = val;
  }

  @Override
  public Type getType() {
    return Type.STRING;
  }

  @Override
  public Object get() {
    return _val;
  }

  @Override
  public boolean getAsBoolean(LocaleContext ctx) {
    // ms access seems to treat strings as "true"
    return true;
  }

  @Override
  public String getAsString(LocaleContext ctx) {
    return _val;
  }

  @Override
  public Integer getAsLongInt(LocaleContext ctx) {
    return roundToLongInt(ctx);
  }

  @Override
  public Double getAsDouble(LocaleContext ctx) {
    return getNumber(ctx).doubleValue();
  }

  @Override
  public BigDecimal getAsBigDecimal(LocaleContext ctx) {
    return getNumber(ctx);
  }

  @Override
  public Value getAsDateTimeValue(LocaleContext ctx) {
    Value dateValue = DefaultDateFunctions.stringToDateValue(ctx, _val);

    if(dateValue == null) {
      // see if string can be coerced to number and then to value date (note,
      // numberToDateValue may return null for out of range numbers)
      try {
        dateValue = DefaultDateFunctions.numberToDateValue(
            getNumber(ctx).doubleValue());
      } catch(EvalException ignored) {
        // not a number, not a date/time
      }

      if(dateValue == null) {
        throw invalidConversion(Type.DATE_TIME);
      }
    }

    // TODO, for now, we can't cache the date value becuase it could be an
    // "implicit" date which would need to be re-calculated on each call
    return dateValue;
  }

  protected BigDecimal getNumber(LocaleContext ctx) {
    if(_num instanceof BigDecimal) {
      return (BigDecimal)_num;
    }
    if(_num == null) {
      // see if it is parseable as a number
      try {
        // ignore extraneous whitespace whitespace and handle "&[hH]" or
        // "&[oO]" prefix (only supports integers)
        String tmpVal = _val.trim();
        if(tmpVal.length() > 0) {

          if(tmpVal.charAt(0) != ValueSupport.NUMBER_BASE_PREFIX) {
            // convert to standard numeric support for parsing
            tmpVal = toCanonicalNumberFormat(ctx, tmpVal);
            _num = ValueSupport.normalize(new BigDecimal(tmpVal));
            return (BigDecimal)_num;
          }

          // parse as hex/octal symbolic value
          if(ValueSupport.HEX_PAT.matcher(tmpVal).matches()) {
            return parseIntegerString(tmpVal, 16);
          } else if(ValueSupport.OCTAL_PAT.matcher(tmpVal).matches()) {
            return parseIntegerString(tmpVal, 8);
          }

          // fall through to NaN
        }
      } catch(NumberFormatException nfe) {
        // fall through to NaN...
      }
      _num = NOT_A_NUMBER;
    }
    throw invalidConversion(Type.DOUBLE);
  }

  private BigDecimal parseIntegerString(String tmpVal, int radix) {
    _num = new BigDecimal(ValueSupport.parseIntegerString(tmpVal, radix));
    return (BigDecimal)_num;
  }

  private static String toCanonicalNumberFormat(LocaleContext ctx, String tmpVal)
  {
    // convert to standard numeric format:
    // - discard any grouping separators
    // - convert decimal separator to '.'
    DecimalFormatSymbols syms = ctx.getNumericConfig().getDecimalFormatSymbols();
    char groupSepChar = syms.getGroupingSeparator();
    tmpVal = StringUtils.remove(tmpVal, groupSepChar);

    char decSepChar = syms.getDecimalSeparator();
    if((decSepChar != ValueSupport.CANON_DEC_SEP) && (tmpVal.indexOf(decSepChar) >= 0)) {
      tmpVal = tmpVal.replace(decSepChar, ValueSupport.CANON_DEC_SEP);
    }

    return tmpVal;
  }
}