How to use

empty

method

in

javaslang.collection.TreeMap

@Override
public void onStart()
{
 this.errors = List.empty();
 this.attr_buffers = TreeMap.empty();
 this.attr_packers = TreeMap.empty();
 this.mesh = null;
 this.header = null;
 this.tri_buffer = null;
 this.tri_packer = null;
}

/**
 * @return The attributes by name
 */
@Value.Derived
default SortedMap<SMFAttributeName, SMFAttribute> attributesByName()
{
 SortedMap<SMFAttributeName, SMFAttribute> m = TreeMap.empty();
 final List<SMFAttribute> ordered = this.attributesInOrder();
 for (int index = 0; index < ordered.size(); ++index) {
  final SMFAttribute attr = ordered.get(index);
  if (m.containsKey(attr.name())) {
   final StringBuilder sb = new StringBuilder(128);
   sb.append("Duplicate attribute name.");
   sb.append(System.lineSeparator());
   sb.append("  Attribute: ");
   sb.append(attr.name().value());
   sb.append(System.lineSeparator());
   throw new IllegalArgumentException(sb.toString());
  }
  m = m.put(attr.name(), attr);
 }
 return m;
}

/**
 * @return The attributes by name
 */
@Value.Derived
default SortedMap<SMFAttributeName, SMFAttribute> attributesByName()
{
 SortedMap<SMFAttributeName, SMFAttribute> m = TreeMap.empty();
 final List<SMFAttribute> ordered = this.attributesInOrder();
 for (int index = 0; index < ordered.size(); ++index) {
  final SMFAttribute attr = ordered.get(index);
  if (m.containsKey(attr.name())) {
   final StringBuilder sb = new StringBuilder(128);
   sb.append("Duplicate attribute name.");
   sb.append(System.lineSeparator());
   sb.append("  Attribute: ");
   sb.append(attr.name().value());
   sb.append(System.lineSeparator());
   throw new IllegalArgumentException(sb.toString());
  }
  m = m.put(attr.name(), attr);
 }
 return m;
}

/**
 * @return A module resolver
 */
public static SMFFilterCommandModuleResolverType create()
{
 SortedMap<String, SMFFilterCommandModuleType> modules =
  TreeMap.empty();
 final ServiceLoader<SMFFilterCommandModuleProviderType> providers =
  ServiceLoader.load(SMFFilterCommandModuleProviderType.class);
 final Iterator<SMFFilterCommandModuleProviderType> iter = providers.iterator();
 while (iter.hasNext()) {
  final SMFFilterCommandModuleProviderType provider = iter.next();
  final SortedMap<String, SMFFilterCommandModuleType> available =
   provider.available();
  for (final String name : available.keySet()) {
   final SMFFilterCommandModuleType module = available.get(name).get();
   if (modules.containsKey(name)) {
    LOG.warn("multiple modules with the same name: {}", name);
   }
   if (LOG.isDebugEnabled()) {
    LOG.debug("registered module {} via provider {}", name, provider);
   }
   modules = modules.put(name, module);
  }
 }
 return new SMFFilterCommandModuleResolver(modules);
}

protected SMFFilterCommandModuleProviderAbstract(
 final SMFFilterCommandModuleType... in_modules)
{
 NullCheck.notNull(in_modules, "Modules");
 SortedMap<String, SMFFilterCommandModuleType> m = TreeMap.empty();
 for (int index = 0; index < in_modules.length; ++index) {
  final SMFFilterCommandModuleType module = in_modules[index];
  if (m.containsKey(module.name())) {
   throw new IllegalArgumentException(
    "Duplicate published module: " + module.name());
  }
  m = m.put(module.name(), module);
 }
 this.available = m;
}

/**
 * @return The packed attributes by octet offset
 */
@Value.Derived
default SortedMap<Integer, SMFByteBufferPackedAttribute> packedAttributesByOffset()
{
 TreeMap<Integer, SMFByteBufferPackedAttribute> output = TreeMap.empty();
 final Seq<SMFAttribute> ordered = this.attributesOrdered();
 int offset = 0;
 for (int index = 0; index < ordered.size(); ++index) {
  final SMFAttribute attr = ordered.get(index);
  final SMFByteBufferPackedAttribute packed =
   SMFByteBufferPackedAttribute.of(attr, index, offset);
  output = output.put(Integer.valueOf(offset), packed);
  offset = Math.addExact(offset, attr.sizeOctets());
 }
 return output;
}

@Override
public Optional<SMFParserEventsDataAttributeValuesType> onDataAttributeStart(
 final SMFAttribute attribute)
{
 TreeMap<Integer, SMFByteBufferAttributePacker> packers = TreeMap.empty();
 final SMFAttributeName name = attribute.name();
 for (final Tuple2<Integer, SMFByteBufferPackingConfiguration> p : this.config) {
  final Integer id = p._1;
  final SMFByteBufferPackingConfiguration bc = p._2;
  final SortedMap<SMFAttributeName, SMFByteBufferPackedAttribute> by_name =
   bc.packedAttributesByName();
  if (by_name.containsKey(name)) {
   final ByteBuffer b = this.attr_buffers.get(id).get();
   final SMFByteBufferPackedAttribute pa = by_name.get(name).get();
   final SMFByteBufferAttributePacker packer =
    new SMFByteBufferAttributePacker(
     this,
     b,
     bc,
     pa,
     this.header.vertexCount());
   packers = packers.put(id, packer);
  }
 }
 this.attr_packers = packers;
 return Optional.of(this);
}