Get a sub-attribute as a date using d-path. If sub-attr's value is a
string, parse it as a {@link Date} using the specified date-time format.

@param attrName
@param dPath
@param dateTimeFormat
@return
509240
public Date getSubAttrAsDate(String attrName, String dPath, String dateTimeFormat) {
        Lock lock = lockForRead();
        try {
            return JacksonUtils.getDate(getAttribute(attrName), dPath, dateTimeFormat);
        } finally {
            lock.unlock();
        }
    }
570392
public static boolean isFormatDita(final String attrFormat) {
        if (attrFormat == null || attrFormat.equals(ATTR_FORMAT_VALUE_DITA)) {
            return true;
        }
        for (final String f : ditaFormat) {
            if (f.equals(attrFormat)) {
                return true;
            }
        }
        return false;
    }
797997
public DateTime toDateTime(Element el, String attributeName, DateTime defaultValue) {

	String value = el.getAttribute(attributeName);
	if (value == null) return defaultValue;
	DateTime dtValue = Caster.toDate(value, false, null, null);
	if (dtValue == null) return defaultValue;
	return dtValue;
    }
240163
public static String getFormattedDate(final Long lastQueryDate, final String datePattern) {
        return formatDate(lastQueryDate, null, datePattern);
    }
965226
@Override
    public Date getDate(String name) {
        Object returnValue = wrappedMap.get(name);
        if ("date.struct".equals(returnValue)) {
            returnValue = lazyEvaluateDateParam(name);
            nestedDateMap.put(name, returnValue);
            return (Date)returnValue;
        }
        Date date = super.getDate(name);
        if (date == null) {
            // try lookup format from messages.properties
            String format = lookupFormat(name);
            if (format != null) {
                return getDate(name, format);
            }
        }
        return date;
    }
636779
public Date getDateProperty(String pstrSection, String pstrProp)
    {
        Date        dtRet   = null;
        String      strVal  = null;
        DateFormat  dtFmt   = null;
        INIProperty objProp = null;
        INISection  objSec  = null;

        objSec = (INISection) this.mhmapSections.get(pstrSection);
        if (objSec != null)
        {
            objProp = objSec.getProperty(pstrProp);
            try
            {
                if (objProp != null) strVal = objProp.getPropValue();
                if (strVal != null)
                {
                    dtFmt = new SimpleDateFormat(this.mstrDateFmt);
                    dtRet = dtFmt.parse(strVal);
                }
            }
            catch (ParseException PExIgnore)
            {
            }
            catch (IllegalArgumentException IAEx)
            {
            }
            finally
            {
                if (objProp != null) objProp = null;
            }
            objSec = null;
        }
        return dtRet;
    }
845241
public <T> Optional<T> getSubAttrOptional(String attrName, String dPath, Class<T> clazz) {
        return Optional.ofNullable(getSubAttr(attrName, dPath, clazz));
    }
524518
public static final String getStringAttribute(Path path, String attribute, LinkOption... options) throws IOException
    {
        attribute = attribute.startsWith("user:") ? attribute : "user:"+attribute;
        byte[] attr = (byte[]) Files.getAttribute(path, attribute, options);
        if (attr == null)
        {
            return null;
        }      
        return new String(attr, UTF_8);
    }
477901
public String getDataSourceName(String typeName, String attributeName, List<String> valuePath) {
		String result;
		String entry = StringUtils.join(valuePath, '.');
		if (typeName != null) {
			result = typeName + attributeName + entry;
		} else {
			result = attributeName + entry;
		}

		if (attributeName.length() > 15) {
			String[] split = StringUtils.splitByCharacterTypeCamelCase(attributeName);
			String join = StringUtils.join(split, '.');
			attributeName = WordUtils.initials(join, INITIALS);
		}
		result = attributeName + DigestUtils.md5Hex(result);

		result = StringUtils.left(result, 19);

		return result;
	}
1360251
public BaseDataJsonFieldBo removeDataAttr(String dPath) {
        Lock lock = lockForWrite();
        try {
            JacksonUtils.deleteValue(dataJson, dPath);
            return (BaseDataJsonFieldBo) setAttribute(ATTR_DATA,
                    SerializationUtils.toJsonString(dataJson), false);
        } finally {
            lock.unlock();
        }
    }
666214
public BaseJsonBo removeSubAttr(String attrName, String dPath) {
        Lock lock = lockForWrite();
        try {
            JsonNode attr = cacheJsonObjs.get(attrName);
            JacksonUtils.deleteValue(attr, dPath);
            return (BaseJsonBo) setAttribute(attrName, SerializationUtils.toJsonString(attr),
                    false);
        } finally {
            lock.unlock();
        }
    }
1230100
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> DatePath<A> get(DatePath<A> path) {
        DatePath<A> newPath = getDate(toString(path), (Class<A>) path.getType());
        return addMetadataOf(newPath, path);
    }
778944
static public String getFormattedTime(long dt, String format, boolean isTime)
    {
        String ret = "";
        SimpleDateFormat df = null;

        try
        {
            if(dt > 0)
            {
                df = formatPool.getFormat(format);
                if(isTime)
                    df.setTimeZone(DateUtilities.getCurrentTimeZone());
                else
                    df.setTimeZone(DateUtilities.defaultTZ);
                ret = df.format(new Date(dt));
            }
        }
        catch(Exception e)
        {
        }

        if(df != null)
            formatPool.release(df);

        return ret;
    }
1280714
@Override
    public Attribute<? super X, ?> getAttribute(String paramName)
    {
        Attribute<? super X, ?> attribute = getDeclaredAttribute(paramName, false);
        if (attribute == null && superClazzType != null)
        {
            attribute = superClazzType.getAttribute(paramName);
        }

        checkForValid(paramName, attribute);
        return attribute;

    }
201346
function parseAttributePath(attrPath, context) {
    const parsed = attrPath.split('.');
    parsed.forEach(item => checkIdentifier(item, context));
    return parsed;
}
1024718
def ctime(self, fpath=None):
        
        return dtformat(
            datetime.datetime.utcfromtimestamp(
                os.path.getctime(fpath or self.fpath)))
129247
public static DateTimeFormatter getDateTimeFormatter(String timeFormat) {
        return JMMap
                .getOrPutGetNew(dateTimeFormatterCache, timeFormat,
                        () -> DateTimeFormatter.ofPattern(timeFormat));
    }