try (java.util.stream.Stream<String> stream = Files.lines(file.toPath())) {
            stream.forEach(lines::add);
        } catch (IOException ex) {
            // If a file can't be read, add an error
            addError(errors, file, new Error(1, "Failed to read file: " + ex.getMessage()));
            return;
        }

        boolean inExample = false; // between ==== ... ====
        List<Snippet> currentSnippets = new ArrayList<>();

	WriteByte(byte) error
	WriteString(string) (int, error)
}

// Builder builder interface
type Builder interface {
	Writer
	WriteQuoted(field interface{})
	AddVar(Writer, ...interface{})
	AddError(error) error
}

// Clause
type Clause struct {
	Name                string // WHERE
	BeforeExpression    Expression
	AfterNameExpression Expression
	AfterExpression     Expression

	return db.Statement.Settings.Load(fmt.Sprintf("%p", db.Statement) + key)
}

// Callback returns callback manager
func (db *DB) Callback() *callbacks {
	return db.callbacks
}

// AddError add error to db
func (db *DB) AddError(err error) error {
	if err != nil {
		if db.Config.TranslateError {
			if errTranslator, ok := db.Dialector.(ErrorTranslator); ok {
				err = errTranslator.Translate(err)
			}
		}

    public boolean hasErrorArtifactExceptions() {
        return errorArtifactExceptions != null;
    }

    public MetadataResolutionResult addError(Exception e) {
        exceptions = initList(exceptions);

        exceptions.add(e);

        return this;
    }

    public List<ArtifactResolutionException> getErrorArtifactExceptions() {

        errorsField.setAccessible(true);
        ((Queue<?>) errorsField.get(null)).clear();
    }

    // Test addError method
    @Test
    public void test_addError_withValidMessage() {
        String errorMsg = "Test error message";
        Crawler.addError(errorMsg);

        try {
            Field errorsField = Crawler.class.getDeclaredField("errors");
            errorsField.setAccessible(true);

     * This method is thread-safe and can be called from multiple crawler threads.
     *
     * @param msg the error message to add; ignored if null or blank
     */
    public static void addError(final String msg) {
        if (StringUtil.isNotBlank(msg)) {
            errors.offer(msg);
        }
    }

    /**
     * Command-line options container for the crawler application.

							stmt.AddError(field.Set(stmt.Context, rv, field.DefaultValueInterface))
						} else if field.AutoCreateTime > 0 || field.AutoUpdateTime > 0 {
							stmt.AddError(field.Set(stmt.Context, rv, curTime))
							values.Values[i][idx], _ = field.ValueOf(stmt.Context, rv)
						}
					} else if field.AutoUpdateTime > 0 && updateTrackTime {
						stmt.AddError(field.Set(stmt.Context, rv, curTime))

			}

			if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
				gorm.Scan(rows, db, mode)

				if db.Statement.Result != nil {
					db.Statement.Result.RowsAffected = db.RowsAffected
				}
				db.AddError(rows.Close())
			}
		}
	}
}

func AfterDelete(db *gorm.DB) {

		err = ErrInvalidTransaction
	}

	if err != nil {
		tx.AddError(err)
	}

	return tx
}

// Commit commits the changes in a transaction
func (db *DB) Commit() *DB {
	if committer, ok := db.Statement.ConnPool.(TxCommitter); ok && committer != nil && !reflect.ValueOf(committer).IsNil() {
		db.AddError(committer.Commit())
	} else {
		db.AddError(ErrInvalidTransaction)
	}
	return db
}

	columns := make([]string, 0, len(mapValues))

	// when the length of mapValues is zero,return directly here
	// no need to call stmt.SelectAndOmitColumns method
	if len(mapValues) == 0 {
		stmt.AddError(gorm.ErrEmptySlice)
		return
	}

	var (
		result                    = make(map[string][]interface{}, len(mapValues))
		selectColumns, restricted = stmt.SelectAndOmitColumns(true, false)
	)