this.source = source;
        this.model = model;
        setGroupId(groupId);
        setArtifactId(artifactId);
        setVersion(version);
    }

    public ModelSource getSource() {
        return source;
    }

    /**
     * Gets the model being wrapped.
     *
     * @return The model or {@code null} if not set.
     */
    public Model getModel() {
        return model;

            return null;
        }

        List<MetadataGraphEdge> res = new ArrayList<>(edges.size());

        for (MetadataGraphEdge e : edges) {
            if (e.getSource().equals(vFrom)) {
                res.add(e);
            }
        }

        return res;
    }
    // ------------------------------------------------------------------------

                    .filter(p -> p.getLocation("version") != null
                            && p.getLocation("version").getSource() != null
                            && defaulModelId.equals(
                                    p.getLocation("version").getSource().getModelId()))
                    .distinct()
                    .map(Plugin::getArtifactId) // managed by us, groupId is always o.a.m.plugins

      <codeSegments>
        <codeSegment>
          <version>1.2.0+</version>
          <code>

    @Override
    public String toString() {
        return getLineNumber() + " : " + getColumnNumber() + ", " + getSource();
    }
          </code>
        </codeSegment>
      </codeSegments>
    </class>
    <class sourceTracker="source">
      <name>InputSource</name>
      <version>1.2.0+</version>
      <fields>

  fun removeAbsentElement() {
    cache.remove("a")
  }

  @Test
  fun readingTheSameStreamMultipleTimes() {
    set("a", "a", "b")
    val snapshot = cache["a"]!!
    assertThat(snapshot.getSource(0)).isSameAs(snapshot.getSource(0))
    snapshot.close()
  }

  @Test
  fun rebuildJournalOnRepeatedReads() {
    set("a", "a", "a")
    set("b", "b", "b")
    while (taskFaker.isIdle()) {

			"cmd":    s.Method,
			"param":  s.Filepath,
			"source": source,
		},
	}
}

func (m *sftpMetrics) log(s *sftp.Request, user string) func(sz int64, err error) {
	startTime := time.Now()
	source := getSource(2)
	return func(sz int64, err error) {
		globalTrace.Publish(sftpTrace(s, startTime, source, user, err, sz))
	}
}

// NewSFTPDriver initializes sftp.Handlers implementation of following interfaces
//

synchronized class AbstractMojoExecutio extends Exception { protected Object source; protected String longMessage; public void AbstractMojoExecutio(String); public void AbstractMojoExecutio(String, Throwable); public String getLongMessage(); public Object getSource(); } org/apache/maven/plugin/ContextEnabled.class package org.apache.maven.plugin; public abstract interface ContextEnabled { public abstract void setPluginContext(java.util.Map); public abstract java.util.Map getPluginContext(); } org/apache/ma...

        }

        if (mojoDescriptor.isOnlineRequired() && session.isOffline()) {
            if (MojoExecution.Source.CLI.equals(mojoExecution.getSource())) {
                Throwable cause = new IllegalStateException(
                        "Goal requires online mode for execution" + " but Maven is currently offline.");
                throw new LifecycleExecutionException(

			"login":  fmt.Sprintf("%t", s.Sess.IsLogin()),
			"source": source,
		},
	}
}

func (m *ftpMetrics) log(s *ftp.Context, paths ...string) func(sz int64, err error) {
	startTime := time.Now()
	source := getSource(2)
	return func(sz int64, err error) {
		globalTrace.Publish(ftpTrace(s, startTime, source, strings.Join(paths, " "), err, sz))
	}
}

// Stat implements ftpDriver

}

func trimTrace(f string) string {
	for _, trimString := range trimStrings {
		f = strings.TrimPrefix(filepath.ToSlash(f), filepath.ToSlash(trimString))
	}
	return filepath.FromSlash(f)
}

func getSource(level int) string {
	pc, file, lineNumber, ok := runtime.Caller(level)
	if ok {
		// Clean up the common prefixes
		file = trimTrace(file)
		_, funcName := filepath.Split(runtime.FuncForPC(pc).Name())