Readonly attributes don't get POSTed.
 (timestamps are included by default)
510345
def readonly_attributes(*attrs)
      @readonly_attributes ||= [:created_at, :updated_at, :completed_at]
      if attrs.any?
        @readonly_attributes.map!(&:to_sym).concat(attrs).uniq!
        setup_attributes(@readonly_attributes, true)
      end
      @readonly_attributes
    end
257071
def publishing_set_update_time(sender, instance, **kwargs):
    
    if hasattr(instance, 'publishing_linked'):
        # Hack to avoid updating `publishing_modified_at` field when a draft
        # publishable item is saved as part of a `publish` operation. This
        # ensures that the `publishing_published_at` timestamp is later than
        # the `publishing_modified_at` timestamp when we publish, which is
        # vital for us to correctly detect whether a draft is "dirty".
        if getattr(instance, '_skip_update_publishing_modified_at', False):
            # Reset flag, in case instance is re-used (e.g. in tests)
            instance._skip_update_publishing_modified_at = False
            return
        instance.publishing_modified_at = timezone.now()
327199
def clean_timestamp(self):
        """"""
        ts = self.cleaned_data["timestamp"]
        if time.time() - ts > (2 * 60 * 60):
            raise forms.ValidationError("Timestamp check failed")
        return ts
51490
def _SyncAttributes(self):
    
    # This effectively moves all the values from the new_attributes to the
    # synced_attributes caches.
    for attribute, value_array in iteritems(self.new_attributes):
      if not attribute.versioned or self.age_policy == NEWEST_TIME:
        # Store the latest version if there are multiple unsynced versions.
        value = value_array[-1]
        self.synced_attributes[attribute] = [
            LazyDecoder(decoded=value, age=value.age)
        ]

      else:
        synced_value_array = self.synced_attributes.setdefault(attribute, [])
        for value in value_array:
          synced_value_array.append(LazyDecoder(decoded=value, age=value.age))

        synced_value_array.sort(key=lambda x: x.age, reverse=True)

    self.new_attributes = {}
    self._to_delete.clear()
    self._dirty = False
    self._new_version = False
46980
static void enableAttribute(ModelNode model) {
        Date enabledTime = new Date();
        DateFormat df = new SimpleDateFormat(DATEFORMAT_ATTR);
        model.get(DeploymentAttributes.ENABLED_TIME.getName()).set(enabledTime.getTime());
        model.get(DeploymentAttributes.ENABLED_TIMESTAMP.getName()).set(df.format(enabledTime));
    }
734092
function readonly( target, attribs ) {
    const attribNames = Object.keys( attribs );
    attribNames.forEach( function ( attName ) {
        const attValue = attribs[ attName ];
        if ( typeof attValue === 'function' ) {
            Object.defineProperty(
                target,
                attName, {
                    set() {
                        throw Error( `Attribute "${attName}" is read only!` );
                    },
                    get: attValue,
                    configurable: false,
                    enumerable: true
                }
            );
        } else {
            Object.defineProperty(
                target,
                attName, {
                    value: attValue,
                    writable: false,
                    configurable: false,
                    enumerable: true
                }
            );
        }
    } );
}
868998
public void setReadOnly(boolean readOnly) {

        m_textbox.setReadOnly(readOnly);
        if (readOnly) {
            addStyleName(CSS.textBoxReadOnly());
        } else {
            removeStyleName(CSS.textBoxReadOnly());
        }
    }
650188
function setUnsynced(fs, path, callback) {
  fs.setxattr(path, constants.attributes.unsynced, Date.now(), callback);
}
1167571
@SuppressWarnings("HiddenField")
  public BaseWindowedBolt withTimestampExtractor(TimestampExtractor timestampExtractor) {
    if (timestampExtractor == null) {
      throw new IllegalArgumentException("Timestamp extractor cannot be set to null");
    }
    if (this.timestampExtractor != null) {
      throw new IllegalArgumentException(
          "Window is already configured with a timestamp " + "extractor: " + timestampExtractor);
    }
    this.timestampExtractor = timestampExtractor;
    return this;
  }
691220
private void applyAutoTimestamp(PropertyMetadata propertyMetadata, long millis) {
    Object timestamp = null;
    Class<?> fieldType = propertyMetadata.getDeclaredType();
    if (Date.class.equals(fieldType)) {
      timestamp = new Date(millis);
    } else if (Calendar.class.equals(fieldType)) {
      Calendar calendar = new Calendar.Builder().setInstant(millis).build();
      timestamp = calendar;
    } else if (Long.class.equals(fieldType) || long.class.equals(fieldType)) {
      timestamp = millis;
    } else if (OffsetDateTime.class.equals(fieldType)) {
      timestamp = OffsetDateTime.ofInstant(Instant.ofEpochMilli(millis), ZoneId.systemDefault());
    } else if (ZonedDateTime.class.equals(fieldType)) {
      timestamp = ZonedDateTime.ofInstant(Instant.ofEpochMilli(millis), ZoneId.systemDefault());
    }
    ValueBuilder<?, ?, ?> valueBuilder = propertyMetadata.getMapper().toDatastore(timestamp);
    valueBuilder.setExcludeFromIndexes(!propertyMetadata.isIndexed());
    entityBuilder.set(propertyMetadata.getMappedName(), valueBuilder.build());
  }
982908
function(allowedAttributes) {
    var tmp = []
    this.forEach(function(record) {
      tmp.push(record.toJson(allowedAttributes))
    })
    return tmp
  }
1156717
def polymorphic_update_timestamp(session, flush_context, instances):
    
    for obj in session.dirty:
        if not isinstance(obj, Entity):
            continue
        state = sa.inspect(obj)
        history = state.attrs["updated_at"].history
        if not any((history.added, history.deleted)):
            obj.updated_at = datetime.utcnow()
812463
public synchronized void setReadOnly()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setReadOnly");

      // And actually mark the real buffers as read-only too
      for (int x = 0; x < dataList.size(); x++)
      {
         WsByteBuffer buff = dataList.get(x);
         buff.setReadOnly(true);
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setReadOnly");
   }
711053
function setModifiedDate (subj, kb, doc) {
      if (SET_MODIFIED_DATES) {
        if (!getOption(tracker, 'trackLastModified')) return
        var deletions = kb.statementsMatching(subject, DCT('modified'))
        deletions = deletions.concat(kb.statementsMatching(subject, WF('modifiedBy')))
        var insertions = [ $rdf.st(subject, DCT('modified'), new Date(), doc) ]
        if (me) insertions.push($rdf.st(subject, WF('modifiedBy'), me, doc))
        updater.update(deletions, insertions, function (uri, ok, body) {})
      }
    }
138443
public void setAll(String attributeName, String busClassNameWithDots, String busClassName, boolean isNullable, RelatedFinder relatedFinder, Map properties, boolean transactional)
    {
        timestampAttribute.setAll(attributeName, busClassNameWithDots, busClassName, isNullable, relatedFinder, properties, transactional);
    }
1193673
public function timestamp()
    {
        $this->updateTime = AnDomainAttributeDate::getInstance();

        if (!isset($this->creationTime)) {
            $this->creationTime = AnDomainAttributeDate::getInstance();
        }
    }
18027
void timestampFormat(DateFormat format, String... attributes) {
        convertWith(new DateToStringConverter(format), attributes);
        convertWith(new StringToTimestampConverter(format), attributes);
    }