/*[deutsch]
<p>Nimmt die untere Grenze von diesem Intervall aus. </p>

@return  changed copy of this interval excluding lower boundary
@since   4.21
557707
public I withOpenStart() {

        if (this.start.isOpen()) {
            return this.getContext();
        } else {
            Boundary<T> b = Boundary.of(IntervalEdge.OPEN, this.start.getTemporal());
            return this.getFactory().between(b, this.end);
        }

    }
409052
public FedoraObject copy() {
        FedoraObject copy = new FedoraObject()
                .pid(pid)
                .state(state)
                .label(label)
                .ownerId(ownerId)
                .createdDate(Util.copy(createdDate))
                .lastModifiedDate(Util.copy(lastModifiedDate));
        for (Datastream ds: datastreams.values()) {
            copy.putDatastream(ds.copy());
        }
        return copy;
    }
677794
public CmsAliasTableRow copy() {

        CmsAliasTableRow result = new CmsAliasTableRow();
        result.setKey(m_key);
        result.setResourcePath(m_resourcePath);
        result.setStructureId(m_structureId);
        result.setChanged(m_isChanged);
        result.setMode(m_mode);
        result.setPathError(m_pathError);
        result.setAliasError(m_aliasError);
        result.setAliasPath(m_aliasPath);
        result.setEdited(m_isEdited);
        result.setOriginalStructureId(m_originalStructureId);

        return result;
    }
992550
public Transformation2D copy() {
		Transformation2D result = new Transformation2D();
		result.xx = xx;
		result.xy = xy;
		result.xd = xd;
		result.yx = yx;
		result.yy = yy;
		result.yd = yd;
		return result;
	}
944139
public AndCondition copy() {
        AndCondition builder = new AndCondition();
        builder.children.addAll(children);
        return builder;
    }
596662
private CompressedISPNChangesBuffer getChangesBufferSafe()
   {
      CompressedISPNChangesBuffer changesContainer = changesList.get();
      if (changesContainer == null)
      {
         throw new IllegalStateException("changesContainer should not be empty");
      }
      return changesContainer;
   }
1079415
public FeatureState copy() {
        FeatureState copy = new FeatureState(feature);
        copy.setEnabled(this.enabled);
        copy.setStrategyId(this.strategyId);
        for (Entry<String, String> entry : this.parameters.entrySet()) {
            copy.setParameter(entry.getKey(), entry.getValue());
        }
        return copy;
    }
141490
public static <T> T[] copyOfRange(final T[] original, final int from, final int to, final int step) {
        return copyOfRange(original, from, to, step, (Class<T[]>) original.getClass());
    }
836687
public T copy() {
        T ret = createLike();
        ret.getMatrix().set(this.getMatrix());
        return ret;
    }
229875
@Override
    ChronoInterval<Moment> newInterval(
        Boundary<Moment> start,
        Boundary<Moment> end
    ) {

        return MomentIntervalFactory.INSTANCE.between(start, end);

    }
1186311
public T copy() {
        T copy = Instantiator.of(type).instantiate();
        return copyInto(copy);
    }
939398
public I collapse() {

        if (this.start.isInfinite()) {
            throw new IllegalStateException(
                "An interval with infinite past cannot be collapsed.");
        }

        T t = this.getClosedFiniteStart();
        Boundary<T> s = Boundary.ofClosed(t);
        Boundary<T> e = Boundary.ofOpen(t);
        return this.getFactory().between(s, e);

    }
949497
public List<Change> asRemovedChanges() {
        final WeeklyOpeningHours normalized = this.normalize();
        final List<Change> changes = new ArrayList<>();
        for (final DayOpeningHours doh : normalized) {
            changes.addAll(doh.asRemovedChanges());
        }
        return changes;
    }
809615
public int originalSize()
    {
        Block<T> currentHeadBlock = getHeadBlock();
        int head = currentHeadBlock.head();
        int size = 0;
        while (true)
        {
            if (head == getBlockSize())
            {
                Block<T> nextHeadBlock = currentHeadBlock.next();
                if (nextHeadBlock == null)
                {
                    break;
                }
                else
                {
                    // Use next block and loop
                    currentHeadBlock = nextHeadBlock;
                    head = currentHeadBlock.head();
                }
            }
            else
            {
                Object element = currentHeadBlock.peek(head);
                if (element == REMOVED_ELEMENT)
                {
                    // Already removed, try next index
                    ++head;
                }
                else if (element != null)
                {
                    ++size;
                    ++head;
                }
                else
                {
                    break;
                }
            }
        }
        return size;
    }
368703
public ChangeEvent<DocumentT> withoutUncommittedWrites() {
    return new ChangeEvent<>(this.getId(),
        this.getOperationType(),
        this.getFullDocument(),
        this.getNamespace(),
        this.getDocumentKey(),
        this.getUpdateDescription(),
        false);
  }
394511
public Version toLowerCase() {
        return new Version(this.major, this.minor, this.patch,
                copyCase(this.preReleaseParts, false),
                copyCase(this.buildMetaDataParts, false));
    }
1283247
public final int getRemaining()
    {
        int rem = 0;
        for (int ii=0;ii<length;ii++)
        {
            rem += srcs[offset+ii].remaining();
        }
        return rem;
    }