LazyFieldLite (statefun-parent 3.2-SNAPSHOT API)

java.lang.Object
- org.apache.flink.statefun.sdk.shaded.com.google.protobuf.LazyFieldLite

Direct Known Subclasses:

LazyField
```
@Generated(value="proto")
public class LazyFieldLite
extends java.lang.Object
```
LazyFieldLite encapsulates the logic of lazily parsing message fields. It stores the message in a ByteString initially and then parses it on-demand.
LazyFieldLite is thread-compatible: concurrent reads are safe once the proto that this LazyFieldLite is a part of is no longer being mutated by its Builder. However, explicit synchronization is needed under read/write situations.
When a LazyFieldLite is used in the context of a MessageLite object, its behavior is considered to be immutable and none of the setter methods in its API are expected to be invoked. All of the getters are expected to be thread-safe. When used in the context of a MessageLite.Builder, setters can be invoked, but there is no guarantee of thread safety.
TODO(yatin,dweis): Consider splitting this class's functionality and put the mutable methods into a separate builder class to allow us to give stronger compile-time guarantees.
This class is internal implementation detail of the protobuf library, so you don't need to use it directly.

Author:

xiangl@google.com (Xiang Li)

Field Summary

Fields
Modifier and Type Field and Description

protected MessageLite value
The parsed value.

Fields
Modifier and Type	Field and Description
`protected MessageLite`	`value` The parsed value.

Constructor Summary

Constructors
Constructor and Description
`LazyFieldLite()` Constructs a LazyFieldLite with no contents, and no ability to parse extensions.
`LazyFieldLite(ExtensionRegistryLite extensionRegistry, ByteString bytes)` Constructs a LazyFieldLite with bytes that will be parsed lazily.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Clears the value state of this instance.
`boolean`	`containsDefaultInstance()` Determines whether this LazyFieldLite instance represents the default instance of this type.
`protected void`	`ensureInitialized(MessageLite defaultInstance)` Might lazily parse the bytes that were previously passed in.
`boolean`	`equals(java.lang.Object o)`
`static LazyFieldLite`	`fromValue(MessageLite value)` Constructs a LazyFieldLite instance with a value.
`int`	`getSerializedSize()` Due to the optional field can be duplicated at the end of serialized bytes, which will make the serialized size changed after LazyField parsed.
`MessageLite`	`getValue(MessageLite defaultInstance)` Returns message instance.
`int`	`hashCode()`
`void`	`merge(LazyFieldLite other)` Merges another instance's contents.
`void`	`mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)` Merges another instance's contents from a stream.
`void`	`set(LazyFieldLite other)` Overrides the contents of this LazyField.
`void`	`setByteString(ByteString bytes, ExtensionRegistryLite extensionRegistry)` Sets this field with bytes to delay-parse.
`MessageLite`	`setValue(MessageLite value)` Sets the value of the instance and returns the old value without delay parsing anything.
`ByteString`	`toByteString()` Returns a BytesString for this field in a thread-safe way.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - value
```
protected volatile MessageLite value
```
    The parsed value. When this is null and a caller needs access to the MessageLite value, then delayedBytes will be parsed lazily at that time.
- Constructor Detail
  - LazyFieldLite
```
public LazyFieldLite(ExtensionRegistryLite extensionRegistry,
                     ByteString bytes)
```
    Constructs a LazyFieldLite with bytes that will be parsed lazily.
  - LazyFieldLite
```
public LazyFieldLite()
```
    Constructs a LazyFieldLite with no contents, and no ability to parse extensions.
- Method Detail
  - fromValue
```
public static LazyFieldLite fromValue(MessageLite value)
```
    Constructs a LazyFieldLite instance with a value. The LazyFieldLite may not be able to parse the extensions in the value as it has no ExtensionRegistry.
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - containsDefaultInstance
```
public boolean containsDefaultInstance()
```
    Determines whether this LazyFieldLite instance represents the default instance of this type.
  - clear
```
public void clear()
```
    Clears the value state of this instance.
    LazyField is not thread-safe for write access. Synchronizations are needed under read/write situations.
  - set
```
public void set(LazyFieldLite other)
```
    Overrides the contents of this LazyField.
    LazyField is not thread-safe for write access. Synchronizations are needed under read/write situations.
  - getValue
```
public MessageLite getValue(MessageLite defaultInstance)
```
    Returns message instance. It may do some thread-safe delayed parsing of bytes.
    
    Parameters:
    
    defaultInstance - its message's default instance. It's also used to get parser for the message type.
  - setValue
```
public MessageLite setValue(MessageLite value)
```
    Sets the value of the instance and returns the old value without delay parsing anything.
    LazyField is not thread-safe for write access. Synchronizations are needed under read/write situations.
  - merge
```
public void merge(LazyFieldLite other)
```
    Merges another instance's contents. In some cases may drop some extensions if both fields contain data. If the other field has an ExtensionRegistry but this does not, then this field will copy over that ExtensionRegistry.
    LazyField is not thread-safe for write access. Synchronizations are needed under read/write situations.
  - mergeFrom
```
public void mergeFrom(CodedInputStream input,
                      ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException
```
    Merges another instance's contents from a stream.
    LazyField is not thread-safe for write access. Synchronizations are needed under read/write situations.
    
    Throws:
    
    java.io.IOException
  - setByteString
```
public void setByteString(ByteString bytes,
                          ExtensionRegistryLite extensionRegistry)
```
    Sets this field with bytes to delay-parse.
  - getSerializedSize
```
public int getSerializedSize()
```
    Due to the optional field can be duplicated at the end of serialized bytes, which will make the serialized size changed after LazyField parsed. Be careful when using this method.
  - toByteString
```
public ByteString toByteString()
```
    Returns a BytesString for this field in a thread-safe way.
  - ensureInitialized
```
protected void ensureInitialized(MessageLite defaultInstance)
```
    Might lazily parse the bytes that were previously passed in. Is thread-safe.

Back to Apache Flink Website

Class LazyFieldLite

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

value

Constructor Detail

LazyFieldLite

LazyFieldLite

Method Detail

fromValue

equals

hashCode

containsDefaultInstance

clear

set

getValue

setValue

merge

mergeFrom

setByteString

getSerializedSize

toByteString

ensureInitialized

Back to Apache Flink Website