text:
/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package ghidra.program.model.data;

import java.net.URL;
import java.util.Collection;

import ghidra.docking.settings.Settings;
import ghidra.docking.settings.SettingsDefinition;
import ghidra.program.model.mem.MemBuffer;
import ghidra.program.model.scalar.Scalar;
import ghidra.util.InvalidNameException;
import ghidra.util.UniversalID;
import ghidra.util.exception.DuplicateNameException;

/**
 * The interface that all datatypes must implement.
 */
public interface DataType {

	/**
	 * WARNING: do not add default method implementations to this interface. Doing so
	 * interferes with correct initialization of the static instance variables {@link #DEFAULT} and
	 * {@link #VOID} below.
	 */

	/**
	 * Singleton instance of default datatype.
	 */
	public static final DataType DEFAULT = DefaultDataType.dataType;

	/**
	 * Instance of void datatype (never use ==)
	 *
	 * @deprecated should use {@link VoidDataType#dataType} instead
	 */
	@Deprecated
	public static final DataType VOID = VoidDataType.dataType;

	public final static String CONFLICT_SUFFIX = ".conflict";

	public final static String TYPEDEF_ATTRIBUTE_PREFIX = "__((";
	public final static String TYPEDEF_ATTRIBUTE_SUFFIX = "))";

	static final long NO_SOURCE_SYNC_TIME = 0L;
	static final long NO_LAST_CHANGE_TIME = 0L;

	/**
	 * Indicates if the length of this data-type is determined based upon the
	 * {@link DataOrganization} obtained from the associated {@link DataTypeManager}.
	 *
	 * @return true length is language/compiler-specification dependent, else false
	 */
	public boolean hasLanguageDependantLength();

	/**
	 * Get the list of settings definitions available for use with this datatype.
	 *

	 * In the case of a {@link TypeDef}, the return list will include the
	 * {@link TypeDefSettingsDefinition} list from the associated base data type.
	 *

	 * Unlike {@link TypeDefSettingsDefinition} standard settings definitions
	 * generally support default, component-default and data-instance use.
	 * In addition, standard settings definitions are never considered during
	 * {@link #isEquivalent(DataType)} checking or during the resolve process.
	 *
	 * @return list of the settings definitions for this datatype.
	 */
	public SettingsDefinition[] getSettingsDefinitions();

	/**
	 * Get the list of all settings definitions for this datatype that may be
	 * used for an associated {@link TypeDef}.  When used for an associated
	 * {@link TypeDef}, these settings will be considered during a
	 * {@link TypeDef#isEquivalent(DataType)} check and will be preserved
	 * during the resolve process.
	 *
	 * @return a list of the settings definitions for a {@link TypeDef}
	 * associated with this datatype.
	 */
	public TypeDefSettingsDefinition[] getTypeDefSettingsDefinitions();

	/**
	 * Gets the settings for this data type.  The settings may have underlying default settings
	 * and may in turn become defaults for instance-specific settings (e.g., Data or DataTypeComponent).
	 * It is important to note that these settings are tied to a specific DataType instantiation
	 * so it is important to understand the scope of its use.  Example: The {@link BuiltInDataTypeManager}
	 * has its own set of DataType instances which are separate from those which have been instantiated
	 * or resolved to a specific Program/Archive {@link DataTypeManager}. Settings manipulation may
	 * be disabled by default in some instances.
	 * @return the settings for this dataType.
	 */
	public Settings getDefaultSettings();

	/**
	 * Returns an instance of this DataType using the specified {@link DataTypeManager} to allow
	 * its use of the corresponding {@link DataOrganization} while retaining its unique identity
	 * (see {@link #getUniversalID()} and archive association (see {@link #getSourceArchive()}) if
	 * applicable.
	 *

	 * This instance will be returned if this datatype's DataTypeManager matches the
	 * specified dtm. The recursion depth of a clone will stop on any datatype whose
	 * {@link DataTypeManager} matches the specified dtm and simply use the existing datatype
	 * instance.
	 *

	 * NOTE: In general, this method should not be used to obtain an instance to be modified.
	 * In most cases changes shuold be made directly to this instance if supported or to a
	 * {@link #copy(DataTypeManager)}.
	 *
	 * @param dtm the data-type manager instance whose data-organization should apply.
	 * @return cloned instance which may be the same as this instance
	 */
	public DataType clone(DataTypeManager dtm);

	/**
	 * Returns a new instance (shallow copy) of this DataType with a new identity and no
	 * source archive association.
	 *

	 * Any reference to other datatypes will use {@link #clone(DataTypeManager)}.
	 *
	 * @param dtm the data-type manager instance whose data-organization should apply.
	 * @return new instanceof of this datatype
	 */
	public DataType copy(DataTypeManager dtm);

	/**
	 * Gets the categoryPath associated with this datatype
	 *
	 * @return the datatype's category path
	 */
	public CategoryPath getCategoryPath();

	/**
	 * Returns the dataTypePath for this datatype;
	 *
	 * @return the dataTypePath for this datatype;
	 */
	public DataTypePath getDataTypePath();

	/**
	 * Set the categoryPath associated with this datatype
	 *
	 * @param path the new path
	 * @throws DuplicateNameException if an attempt to place this datatype into the specified
	 *             category resulted in a name collision. This should not occur for non-DB DataType
	 *             instances.
	 */
	public void setCategoryPath(CategoryPath path) throws DuplicateNameException;

	/**
	 * Get the DataTypeManager containing this datatype.
	 *

	 * This association should not be used to indicate whether this DataType has been resolved, but
	 * is intended to indicate whether the appropriate DataOrganization is being used.
	 *
	 * @return the DataTypeManager that is associated with this datatype.
	 */
	public DataTypeManager getDataTypeManager();

	/**
	 * Gets the name for referring to this datatype.
	 *
	 * @return generic name for this Data Type (i.e.: Word)
	 */
	public String getDisplayName();

	/**
	 * Get the name of this datatype.
	 *
	 * @return the name
	 */
	public String getName();

	/**
	 * Get the full category path name that includes this datatype's name.
	 *

	 * If the category is null, then this just the datatype's name is returned.
	 *
	 * @return the path, or just this type's name
	 */
	public String getPathName();

	/**
	 * Sets the name of the datatype
	 *
	 * @param name the new name for this datatype.
	 * @throws InvalidNameException if the given name does not form a valid name.
	 * @throws DuplicateNameException if name change on stored {@link DataType} is a duplicate of
	 *             another datatype within the same category (only applies to DB stored
	 *             {@link DataType}).
	 */
	public void setName(String name) throws InvalidNameException, DuplicateNameException;

	/**
	 * Sets the name and category of a datatype at the same time.
	 *
	 * @param path the new category path.
	 * @param name the new name
	 * @throws InvalidNameException if the name is invalid
	 * @throws DuplicateNameException if name change on stored {@link DataType} is a duplicate of
	 *             another datatype within the same category (only applies to DB stored
	 *             {@link DataType}).
	 */
	public void setNameAndCategory(CategoryPath path, String name)
			throws InvalidNameException, DuplicateNameException;

	/**
	 * Get the mnemonic for this DataType.
	 *
	 * @param settings settings which may influence the result or null
	 * @return the mnemonic for this DataType.
	 */
	public String getMnemonic(Settings settings);

	/**
	 * Get the length (number of 8-bit bytes) of this DataType.
	 *

	 * NOTE: No datatype should ever return 0, even if {@link #isZeroLength()}, and only
	 * {@link Dynamic} datatypes should return -1. If {@link #isZeroLength()} is true a length of 1
	 * should be returned. Where a zero-length datatype can be handled (e.g., {@link Composite}) the
	 * {@link #isZeroLength()} method should be used.
	 *
	 * @return the length of this DataType
	 */
	public int getLength();

	/**
	 * Indicates this datatype is defined with a zero length.
	 *

	 * This method should not be confused with {@link #isNotYetDefined()} which indicates that
	 * nothing but the name and basic type is known.
	 *

	 * NOTE: a zero-length datatype must return a length of 1 via {@link #getLength()}. Zero-length
	 * datatypes used as a component within a {@link Composite} may, or may not, be assigned a
	 * component length of 0. The method {@link DataTypeComponent#usesZeroLengthComponent(DataType)}
	 * is used to make this determination.
	 *
	 * @return true if type definition has a length of 0, else false
	 */
	public boolean isZeroLength();

	/**
	 * Indicates if this datatype has not yet been fully defined.
	 *

	 * Such datatypes should always return a {@link #getLength()} of 1 and true for
	 * {@link #isZeroLength()}. (example: empty structure)
	 *
	 * @return true if this type is not yet defined.
	 */
	public boolean isNotYetDefined();

	/**
	 * Get a String briefly describing this DataType.
	 *
	 * @return a one-liner describing this DataType.
	 */
	public String getDescription();

	/**
	 * Sets a String briefly describing this DataType.
	 *
	 * @param description a one-liner describing this DataType.
	 * @throws UnsupportedOperationException if the description is not allowed to be set for this
	 *             datatype.
	 */
	public void setDescription(String description) throws UnsupportedOperationException;

	/**
	 * The getDocs method should provide a URL pointing to extended documentation for this DataType
	 * if it exists.
	 *

	 * A typical use would be to return a URL pointing to the programmers reference for this
	 * instruction or a page describing this data structure.
	 *
	 * @return null - there is no URL documentation for this prototype.
	 */
	public URL getDocs();

	/**
	 * Get the interpretted data value in the form of the appropriate Object for this DataType.
	 * This method must return a value consistent with {@link #getValueClass(Settings)}.
	 *

	 * For instance, if this datatype is a {@link Pointer} an Address object or null should be returned.
	 * A Byte, returns a {@link Scalar} object.
	 *
	 * @param buf the data buffer.
	 * @param settings the settings to use.
	 * @param length the number of bytes to get the value from.
	 * @return the data Object.
	 */
	public Object getValue(MemBuffer buf, Settings settings, int length);

	/**
	 * Check if this type supports encoding (patching)
	 *

	 * If unsupported, {@link #encodeValue(Object, MemBuffer, Settings, int)} and
	 * {@link #encodeRepresentation(String, MemBuffer, Settings, int)} will always throw an
	 * exception. Actions which rely on either {@code encode} method should not be displayed if the
	 * applicable datatype is not encodable.
	 *
	 * @return true if encoding is supported
	 */
	public boolean isEncodable();

	/**
	 * Encode bytes from an Object appropriate for this DataType.
	 *

	 * Converts the given object to the byte encoding and returns it. When appropriate, this should
	 * seek the nearest encoding to the specified value, since the object may come from a user
	 * script. For example, a floating-point value may be rounded. Invalid values should be rejected
	 * with a {@link DataTypeEncodeException}.
	 *
	 * @param value the desired value.
	 * @param buf a buffer representing the eventual destination of the bytes.
	 * @param settings the settings to use.
	 * @param length the expected length of the result, usually the length of the data unit, or -1
	 *            to let the type choose the length. It may be ignored, e.g., for fixed-length
	 *            types.
	 * @return the encoded value.
	 * @throws DataTypeEncodeException if the value cannot be encoded for any reason, e.g.,
	 *             incorrect type, not enough space, buffer overflow, unsupported (see
	 *             {@link #isEncodable()}).
	 */
	public byte[] encodeValue(Object value, MemBuffer buf, Settings settings, int length)
			throws DataTypeEncodeException;

	/**
	 * Get the Class of the value Object to be returned by this datatype
	 * (see {@link #getValue(MemBuffer, Settings, int)}).
	 *
	 * @param settings the relevant settings to use or null for default.
	 * @return Class of the value to be returned by this datatype or null if it can vary or is
	 *         unspecified. Types which correspond to a string or char array will return the String
	 *         class.
	 */
	public Class<?> getValueClass(Settings settings);

	/**
	 * Returns the appropriate string to use as the default label prefix in the absence of any data.
	 *
	 * @return the default label prefix or null if none specified.
	 */
	public String getDefaultLabelPrefix();

	/**
	 * Returns the prefix to use for this datatype when an abbreviated prefix is desired.
	 *

	 * For example, some datatypes will built a large default label, at which is is more desirable
	 * to have a shortened prefix.
	 *
	 * @return the prefix to use for this datatype when an abbreviated prefix is desired. May return
	 *         null.
	 */
	public String getDefaultAbbreviatedLabelPrefix();

	/**
	 * Returns the appropriate string to use as the default label prefix.
	 *
	 * @param buf memory buffer containing the bytes.
	 * @param settings the Settings object
	 * @param len the length of the data.
	 * @param options options for how to format the default label prefix.
	 * @return the default label prefix or null if none specified.
	 */
	public String getDefaultLabelPrefix(MemBuffer buf, Settings settings, int len,
			DataTypeDisplayOptions options);

	/**
	 * Returns the appropriate string to use as the default label prefix.
	 *

	 * This takes into account the fact that there exists a reference to the data that references
	 * offcutLength bytes into this type
	 *
	 * @param buf memory buffer containing the bytes.
	 * @param settings the Settings object
	 * @param len the length of the data.
	 * @param options options for how to format the default label prefix.
	 * @param offcutOffset offset into datatype
	 * @return the default label prefix.
	 */
	public String getDefaultOffcutLabelPrefix(MemBuffer buf, Settings settings, int len,
			DataTypeDisplayOptions options, int offcutOffset);

	/**
	 * Get bytes from memory in a printable format for this type.
	 *
	 * @param buf the data.
	 * @param settings the settings to use for the representation.
	 * @param length the number of bytes to represent.
	 * @return the representation of the data in this format, never null.
	 */
	public String getRepresentation(MemBuffer buf, Settings settings, int length);

	/**
	 * Encode bytes according to the display format for this type.
	 *

	 * Converts the given representation to the byte encoding and returns it. When appropriate, this
	 * should seek the nearest encoding to the specified value, since the representation is likely
	 * coming from user input. For example, a floating-point value may be rounded. Invalid
	 * representations should be rejected with a {@link DataTypeEncodeException}.
	 *
	 * @param repr the representation of the desired value, as in
	 *            {@link #getRepresentation(MemBuffer, Settings, int)}. The supported formats depend
	 *            on the specific datatype and its settings.
	 * @param buf a buffer representing the eventual destination of the bytes.
	 * @param settings the settings to use for the representation.
	 * @param length the expected length of the result, usually the length of the data unit, or -1
	 *            to let the type choose the length. It may be ignored, e.g., for fixed-length
	 *            types.
	 * @return the encoded value.
	 * @throws DataTypeEncodeException if the value cannot be encoded for any reason, e.g.,
	 *             incorrect format, not enough space, buffer overflow, unsupported (see
	 *             {@link #isEncodable()}).
	 */
	public byte[] encodeRepresentation(String repr, MemBuffer buf, Settings settings, int length)
			throws DataTypeEncodeException;

	/**
	 * Returns true if this datatype has been deleted and is no longer valid
	 *
	 * @return true if this datatype has been deleted and is no longer valid.
	 */
	public boolean isDeleted();

	/**
	 * Check if the given datatype is equivalent to this datatype.
	 *

	 * The precise meaning of "equivalent" is datatype dependent.

	 * NOTE: if invoked by a DB object or manager it should be invoked on the DataTypeDB object
	 * passing the other datatype as the argument.
	 *
	 * @param dt the datatype being tested for equivalence.
	 * @return true if the if the given datatype is equivalent to this datatype.
	 */
	public boolean isEquivalent(DataType dt);

	/**
	 * Notification that the given datatype's size has changed.
	 *

	 * DataTypes may need to make internal changes in response.

	 * TODO: This method is reserved for internal DB use.

	 *
	 * @param dt the datatype that has changed.
	 */
	public void dataTypeSizeChanged(DataType dt);

	/**
	 * Notification that the given datatype's alignment has changed.
	 *

	 * DataTypes may need to make internal changes in response.

	 * TODO: This method is reserved for internal DB use.

	 *
	 * @param dt the datatype that has changed.
	 */
	public void dataTypeAlignmentChanged(DataType dt);

	/**
	 * Informs this datatype that the given datatype has been deleted.
	 *

	 * TODO: This method is reserved for internal DB use.

	 *
	 * @param dt the datatype that has been deleted.
	 */
	public void dataTypeDeleted(DataType dt);

	/**
	 * Informs this datatype that the given oldDT has been replaced with newDT
	 *

	 * TODO: This method is reserved for internal DB use.

	 *
	 * @param oldDt old datatype
	 * @param newDt new datatype
	 */
	public void dataTypeReplaced(DataType oldDt, DataType newDt);

	/**
	 * Inform this data type that it has the given parent
	 *

	 * TODO: This method is reserved for internal DB use.
	 *
	 * @param dt parent data type
	 */
	public void addParent(DataType dt);

	/**
	 * Remove a parent datatype
	 *

	 * TODO: This method is reserved for internal DB use.

	 *
	 * @param dt parent datatype
	 */
	public void removeParent(DataType dt);

	/**
	 * Informs this datatype that its name has changed from the indicated old name.
	 *

	 * TODO: This method is reserved for internal DB use.

	 *
	 * @param dt the datatype whose name changed
	 * @param oldName the datatype's old name
	 */
	public void dataTypeNameChanged(DataType dt, String oldName);

	/**
	 * Get the parents of this datatype.
	 *
	 * NOTE: This method is intended to be used on a DB-managed datatype only and is not
	 * fully supported for use with non-DB datatype instances.
	 * @return parents of this datatype
	 */
	public Collection<DataType> getParents();

	/**
	 * Gets the alignment to be used when aligning this datatype within another datatype.
	 *
	 * @return this datatype's alignment.
	 */
	public int getAlignment();

	/**
	 * Check if this datatype depends on the existence of the given datatype.
	 *

	 * For example byte[] depends on byte. If byte were deleted, then byte[] would also be deleted.
	 *
	 * @param dt the datatype to test that this datatype depends on.
	 * @return true if the existence of this datatype relies on the existence of the specified
	 *         datatype dt.
	 */
	public boolean dependsOn(DataType dt);

	/**
	 * Get the source archive where this type originated
	 *
	 * @return source archive object
	 */
	public SourceArchive getSourceArchive();

	/**
	 * Set the source archive where this type originated
	 *
	 * @param archive source archive object
	 */
	public void setSourceArchive(SourceArchive archive);

	/**
	 * Get the timestamp corresponding to the last time this type was changed within its datatype
	 * manager
	 *
	 * @return timestamp of last change within datatype manager
	 */
	public long getLastChangeTime();

	/**
	 * Get the timestamp corresponding to the last time this type was sync'd within its source
	 * archive
	 *
	 * @return timestamp of last sync with source archive
	 */
	public long getLastChangeTimeInSourceArchive();

	/**
	 * Get the universal ID for this datatype.
	 *

	 * This value is intended to be a unique identifier across all programs and archives. The same
	 * ID indicates that two datatypes were originally the same one. Keep in mind names, categories,
	 * and component makeup may differ and have changed since there origin.
	 *
	 * @return datatype UniversalID
	 */
	public UniversalID getUniversalID();

	/**
	 * For datatypes that support change, this method replaces the internals of this datatype with
	 * the internals of the given datatype.
	 *

	 * The datatypes must be of the same "type" (i.e. structure can only be replacedWith another
	 * structure.
	 *
	 * @param dataType the datatype that contains the internals to upgrade to.
	 * @throws UnsupportedOperationException if the datatype does not support change.
	 * @throws IllegalArgumentException if the given datatype is not the same type as this datatype.
	 */
	public void replaceWith(DataType dataType);

	/**
	 * Sets the lastChangeTime for this datatype.
	 *

	 * Normally, this is updated automatically when a datatype is changed, but when committing or
	 * updating while synchronizing an archive, the lastChangeTime may need to be updated
	 * externally.
	 *
	 * @param lastChangeTime the time to use as the lastChangeTime for this datatype
	 */
	public void setLastChangeTime(long lastChangeTime);

	/**
	 * Sets the lastChangeTimeInSourceArchive for this datatype.
	 *

	 * This is used by when a datatype change is committed back to its source archive.
	 *
	 * @param lastChangeTimeInSourceArchive the time to use as the lastChangeTimeInSourceArchive for
	 *            this datatype
	 */
	public void setLastChangeTimeInSourceArchive(long lastChangeTimeInSourceArchive);

	/**
	 * Returns the DataOrganization associated with this data-type
	 *
	 * @return associated data organization
	 */
	public DataOrganization getDataOrganization();

}


text:
#include "dm_qframe.h"

namespace interval
{
namespace sturm_bvp
{

template<class IBASIS>
IBASIS* DM_QFrame::Problem<IBASIS>::createWaveletSystem(int jmax)
{
    bool bc_left = true;
    bool bc_right = true;

    IBASIS* basis = new IBASIS(bc_left, bc_right);
    basis->set_jpmax(jmax, this->lastInput_.pmax);

    return basis;
}

template<class IBASIS>
WaveletTL::SturmQFrameEquation<IBASIS>*
DM_QFrame::Problem<IBASIS>::createDiscretizedEquation(const MathTL::SimpleSturmBVP& rawProblem,
                                                      const IBASIS& basis)
{
    return new WaveletTL::SturmQFrameEquation<IBASIS>(rawProblem, basis, true);
}

}
}

// explicit template instantiation:
template class Instantiate<interval::sturm_bvp::DM_QFrame>;

redpajama_set_name: RedPajamaGithub


text:
package types

import (
	"fmt"
	"os"
	"regexp"
	"runtime"
	"runtime/debug"
	"strings"
)

type CodeLocation struct {
	FileName       string `json:",omitempty"`
	LineNumber     int    `json:",omitempty"`
	FullStackTrace string `json:",omitempty"`
	CustomMessage  string `json:",omitempty"`
}

func (codeLocation CodeLocation) String() string {
	if codeLocation.CustomMessage != "" {
		return codeLocation.CustomMessage
	}
	return fmt.Sprintf("%s:%d", codeLocation.FileName, codeLocation.LineNumber)
}

func (codeLocation CodeLocation) ContentsOfLine() string {
	if codeLocation.CustomMessage != "" {
		return ""
	}
	contents, err := os.ReadFile(codeLocation.FileName)
	if err != nil {
		return ""
	}
	lines := strings.Split(string(contents), "\n")
	if len(lines) < codeLocation.LineNumber {
		return ""
	}
	return lines[codeLocation.LineNumber-1]
}

func NewCustomCodeLocation(message string) CodeLocation {
	return CodeLocation{
		CustomMessage: message,
	}
}

func NewCodeLocation(skip int) CodeLocation {
	_, file, line, _ := runtime.Caller(skip + 1)
	return CodeLocation{FileName: file, LineNumber: line}
}

func NewCodeLocationWithStackTrace(skip int) CodeLocation {
	_, file, line, _ := runtime.Caller(skip + 1)
	stackTrace := PruneStack(string(debug.Stack()), skip+1)
	return CodeLocation{FileName: file, LineNumber: line, FullStackTrace: stackTrace}
}

// PruneStack removes references to functions that are internal to Ginkgo
// and the Go runtime from a stack string and a certain number of stack entries
// at the beginning of the stack. The stack string has the format
// as returned by runtime/debug.Stack. The leading goroutine information is
// optional and always removed if present. Beware that runtime/debug.Stack
// adds itself as first entry, so typically skip must be >= 1 to remove that
// entry.
func PruneStack(fullStackTrace string, skip int) string {
	stack := strings.Split(fullStackTrace, "\n")
	// Ensure that the even entries are the method names and the
	// the odd entries the source code information.
	if len(stack) > 0 && strings.HasPrefix(stack[0], "goroutine ") {
		// Ignore "goroutine 29 [running]:" line.
		stack = stack[1:]
	}
	// The "+1" is for skipping over the initial entry, which is
	// runtime/debug.Stack() itself.
	if len(stack) > 2*(skip+1) {
		stack = stack[2*(skip+1):]
	}
	prunedStack := []string{}
	if os.Getenv("GINKGO_PRUNE_STACK") == "FALSE" {
		prunedStack = stack
	} else {
		re := regexp.MustCompile(`\/ginkgo\/|\/pkg\/testing\/|\/pkg\/runtime\/`)
		for i := 0; i < len(stack)/2; i++ {
			// We filter out based on the source code file name.
			if !re.Match([]byte(stack[i*2+1])) {
				prunedStack = append(prunedStack, stack[i*2])
				prunedStack = append(prunedStack, stack[i*2+1])
			}
		}
	}
	return strings.Join(prunedStack, "\n")
}


text:
class BosonMomentumSampler : public MomentumSamplerBase {
 private:
    double m0_;
    int trunc_order_;

 public:
    BosonMomentumSampler(std::shared_ptr<RandomUtil::Random> ran_gen,
                         double m0, int trunc_order);
    ~BosonMomentumSampler() {};

    double CDF_0(const double Etilde) const;
    double CDF_1(const double Etilde) const;
    double CDF_2(const double Etilde) const;
    double CDF_0(const double Etilde, const double mtilde) const;
    double CDF_1(const double Etilde, const double mtilde) const;
    double CDF_2(const double Etilde, const double mtilde) const;
};

#endif  // SRC_BosonMomentumSampler_


text:
using UnityEngine;
using System.Collections;

public class UnitPlayer : Unit {

	// Use this for initialization
	public override void Start () {
		base.Start ();
	}

	// Update is called once per frame
	public override void Update () {

		// rotation

		transform.Rotate (0f, Input.GetAxis ("Mouse X") * turnSpeed * Time.deltaTime, 0f);

		// movement
		move = new Vector3 (Input.GetAxis("Horizontal"),0f,Input.GetAxis("Vertical"));

		move.Normalize ();

		move = transform.TransformDirection (move);

		if(Input.GetKeyDown(KeyCode.Space) && control.isGrounded){
			jump = true;
		}

		running = Input.GetKey (KeyCode.LeftShift) || Input.GetKey (KeyCode.RightShift);

		base.Update ();
	}
}


text:
namespace app { namespace Fuse { namespace Controls { struct ScrollView; } } }
namespace app { namespace Fuse { struct Node; } }
namespace app { namespace Uno { struct Float2; } }

namespace app {
namespace Fuse {
namespace Android {

struct ParentView__Fuse_Controls_ScrollView;

struct ParentView__Fuse_Controls_ScrollView__uType : ::app::Fuse::Android::NativeView__uType
{
    void(*__fp_Attach)(ParentView__Fuse_Controls_ScrollView*);
    void(*__fp_Detach)(ParentView__Fuse_Controls_ScrollView*);
};

ParentView__Fuse_Controls_ScrollView__uType* ParentView__Fuse_Controls_ScrollView__typeof();

void ParentView__Fuse_Controls_ScrollView___ObjInit_2(ParentView__Fuse_Controls_ScrollView* __this);
void ParentView__Fuse_Controls_ScrollView__Attach(ParentView__Fuse_Controls_ScrollView* __this);
void ParentView__Fuse_Controls_ScrollView__Detach(ParentView__Fuse_Controls_ScrollView* __this);
::app::Fuse::Controls::ScrollView* ParentView__Fuse_Controls_ScrollView__get_Control(ParentView__Fuse_Controls_ScrollView* __this);
::app::Uno::Float2 ParentView__Fuse_Controls_ScrollView__get_Size(ParentView__Fuse_Controls_ScrollView* __this);
void ParentView__Fuse_Controls_ScrollView__OnRooted(ParentView__Fuse_Controls_ScrollView* __this, ::app::Fuse::Node* n);
void ParentView__Fuse_Controls_ScrollView__OnUnrooted(ParentView__Fuse_Controls_ScrollView* __this, ::app::Fuse::Node* n);

struct ParentView__Fuse_Controls_ScrollView : ::app::Fuse::Android::NativeView
{
    void _ObjInit_2() { ParentView__Fuse_Controls_ScrollView___ObjInit_2(this); }
    void Attach() { (((ParentView__Fuse_Controls_ScrollView__uType*)this->__obj_type)->__fp_Attach)(this); }
    void Detach() { (((ParentView__Fuse_Controls_ScrollView__uType*)this->__obj_type)->__fp_Detach)(this); }
    ::app::Fuse::Controls::ScrollView* Control() { return ParentView__Fuse_Controls_ScrollView__get_Control(this); }
};

}}}

#endif


text:
package org.apache.predictionio.data

/** If you are an engine developer, please refer to the [[store]] package.
  *
  * This package provides convenient access to underlying data access objects.
  * The common entry point is [[Storage]].
  *
  * Developer APIs are available to advanced developers to add support of other
  * data store backends.
  */
package object storage {}


text:
package kg.apc.charting.rows;

import kg.apc.charting.AbstractGraphPanelChartElement;
import kg.apc.charting.elements.GraphPanelChartAverageElement;
import kg.apc.charting.rows.GraphRowOverallAverages;
import java.util.Iterator;

import org.junit.*;

import static org.junit.Assert.*;

public class GraphRowOverallAveragesTest
{
   /**
    *
    */
   public GraphRowOverallAveragesTest()
   {
   }

   /**
    *
    * @throws Exception
    */
   @BeforeClass
   public static void setUpClass()
        throws Exception
   {
   }

   /**
    *
    * @throws Exception
    */
   @AfterClass
   public static void tearDownClass()
        throws Exception
   {
   }

   /**
    *
    */
   @Before
   public void setUp()
   {
   }

   /**
    *
    */
   @After
   public void tearDown()
   {
   }

   /**
    * Test of add method, of class GraphRowOverallAverages.
    */
   @Test
   public void testAdd()
   {
      System.out.println("add");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      instance.add(0, 0);
      assertEquals(0, instance.getKey(), 0.01);
      assertEquals(0, instance.getValue().getValue(), 0.01);

      instance.add(1, 1);
      assertEquals(1, instance.getKey(), 0.01);
      assertEquals(0.5, instance.getValue().getValue(), 0.01);

      instance.add(1, 1);
      assertEquals(1, instance.getKey(), 0.01);
      assertEquals(0.66, instance.getValue().getValue(), 0.01);

      instance.add(5, 10);
      assertEquals(2, instance.getKey(), 0.01);
      assertEquals(3, instance.getValue().getValue(), 0.01);
   }

   /**
    * Test of iterator method, of class GraphRowOverallAverages.
    */
   @Test
   public void testIterator()
   {
      System.out.println("iterator");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      Iterator expResult = instance;
      Iterator result = instance.iterator();
      Assert.assertEquals(expResult, result);
   }

   /**
    * Test of hasNext method, of class GraphRowOverallAverages.
    */
   @Test
   public void testHasNext()
   {
      System.out.println("hasNext");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      Assert.assertTrue(instance.hasNext());
      assertEquals(instance, instance.next());
      Assert.assertFalse(instance.hasNext());
   }

   /**
    * Test of next method, of class GraphRowOverallAverages.
    */
   @Test
   public void testNext()
   {
      System.out.println("next");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      assertEquals(instance, instance.next());
   }

   /**
    * Test of remove method, of class GraphRowOverallAverages.
    */
   @Test
   public void testRemove()
   {
      System.out.println("remove");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      try
      {
         instance.remove();
         Assert.fail("Exception expected");
      }
      catch (UnsupportedOperationException e)
      {
      }
   }

   /**
    * Test of getKey method, of class GraphRowOverallAverages.
    */
   @Test
   public void testGetKey()
   {
      System.out.println("getKey");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      long expResult = 0;
      long result = instance.getKey();
      Assert.assertEquals(expResult, result);
   }

   /**
    * Test of getValue method, of class GraphRowOverallAverages.
    */
   @Test
   public void testGetValue()
   {
      System.out.println("getValue");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      GraphPanelChartAverageElement result = instance.getValue();
      assertEquals(0, result.getValue(), 0.01);
   }

   /**
    * Test of setValue method, of class GraphRowOverallAverages.
    */
   @Test
   public void testSetValue()
   {
      System.out.println("setValue");
      GraphPanelChartAverageElement value = null;
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      try
      {
         AbstractGraphPanelChartElement result = instance.setValue(value);
         Assert.fail("Exception expected");
      }
      catch (UnsupportedOperationException e)
      {
      }
   }

   @Test
   public void testSize()
   {
      System.out.println("size");
      GraphRowOverallAverages instance = new GraphRowOverallAverages();
      int expResult = 1;
      int result = instance.size();
      Assert.assertEquals(expResult, result);
   }

    /**
     * Test of getElement method, of class GraphRowOverallAverages.
     */
    @Test
    public void testGetElement()
    {
        System.out.println("getElement");

        long value = 100L;
        GraphRowOverallAverages instance = new GraphRowOverallAverages();
        AbstractGraphPanelChartElement expResult = new GraphPanelChartAverageElement(10);
        instance.add(value, 10);
        AbstractGraphPanelChartElement result = instance.getElement(value);
        Assert.assertTrue(instance.getElement(value).getValue() == expResult.getValue());
    }
}


text:
@ECHO OFF
setlocal

  REM  This variable sets the com port of your host system and the baud rate at
  REM  which ICAT communicates w/ KDB.  Note that at speeds > 19200, you will
  REM  need buffered UARTs on both the host and victim machines.

  SET  CAT_MACHINE=COM2:115200

  REM  This variable is used by the iprobe library to start initial
  REM  communication w/ KDB.  If it's not specified, the iprobe library defaults
  REM  to 9600.  In most cases, you do NOT need to set this variable.  The
  REM  iprobe library will try to communicate initially w/ KDB at this rate, and
  REM  if that fails, it will try to communicate at the CAT_MACHINE baud rate
  REM  (the rate at which you want to have ICAT and KDB communicating).  We
  REM  invented this variable in case you were previously communicating w/ KDB
  REM  (say using zoc or t) at a rate different from 9600 or the CAT_MACHINE
  REM  rate.
  REM
  REM  This variable is important, however, when ICAT is closed down.  If ICAT
  REM  has this variable set, it will reset KDB to this rate on shut down.
  REM  This facilitates those who want ICAT to communicate at the higher baud
  REM  rates yet want to use terminal emulators before and after that can not
  REM  handle the higher baud rates.

  SET  CAT_SETUP_RATE=9600

  REM  This variable tells ICAT where to find your debug binaries (the .sys
  REM  and .exe files w/ debug information) on your host system.  You should
  REM  put doscalls.cvk (renamed to OS2KRNL) in this host machine subdir IFF
  REM  you are debugging OS/2 kernel code.  Ensure that the version of
  REM  doscalls.cvk lines up w/ the OS2KRNLD that you boot on the victim
  REM  machine, please!

  SET  CAT_HOST_BIN_PATH=n:\base\src\dev\mme\smp401;n:\base\src\dev\mme\midi;n:\base\src\vdev\mme\vmpu401

  REM  This variable is for async communications.  W/ the uKernel, we could
  REM  use token ring and ethernet, too.  Maybe someday w/ Merlin we can.  For
  REM  now, use ASYNC_SIGBRK.

  SET  CAT_COMMUNICATION_TYPE=ASYNC_SIGBRK

  REM  This variable tells ICAT where to find your source (SAMPLEDD.ASM and
  REM  SAMPLE.C) in the demo.  If you are debugging the kernel, ensure that
  REM  your source paths are included here for the kernel components of
  REM  interest.

  SET  CAT_HOST_SOURCE_PATH=%CAT_HOST_BIN_PATH%;n:\base\src\dev\mme\wpddlib;n:\base\h

  REM  This variable causes a recursive search of the subdirectories below the
  REM  subdirectories listed in CAT_HOST_BIN_PATH and CAT_HOST_SOURCE_PATH.
  REM  For example, with the CAT_HOST_SOURCE_PATH variable above, ICAT will
  REM  search the samdetw subdirectory and all subdirectories below samdetw as
  REM  well as their subdirectories, ad nauseam.  This variable defaults to NULL
  REM  so that ICAT will NOT do the recursive search.  Setting this variable to
  REM  any non-null value causes the recursive search to be performed.

  SET  CAT_PATH_RECURSE=

  REM  This variable allows ICAT to disregard all modules other than OS2KRNL and
  REM  the ones specified in the string.  If this variable is null, the iprobe
  REM  library will return all modules to ICAT.  ICAT takes time processing each
  REM  module, so it is often a good idea for performance to supply this
  REM  variable.
  REM
  REM  You can separate the various modules w/ a ';' or a ' '.  (Actually, use
  REM  any delimiter you want as the iprobe library uses strstr on the list to
  REM  see if it should tell ICAT about a module or not.)  The module name must
  REM  be the full name; e.g., mmpmcrts.dll instead of just mmpmcrts.

  SET  CAT_MODULE_LIST=mpu401.sys vmpu401.sys midi.sys

  REM  This variable allows ICAT to resume the system on its initialization.
  REM  You will rarely (if ever) want to do this.  When you invoke icatgam, it
  REM  initializes the COMx port and breaks into KDB.  Then it changes the baud
  REM  rate (when necessary), and it leaves control of KDB in icatgam's hands.
  REM
  REM  This is really important if you are attaching to a system that has
  REM  already reached a failure or has an embedded int3 (device drivers often
  REM  do).  As such, the default is for CAT_RESUME to be NULL.
  REM
  REM  There could be situations where you want to initialize icatgam, but
  REM  somehow time your attach to the OS2KRNL via the [Attach] option.  In
  REM  this rare case, you may want to set CAT_RESUME=ON, and then icatgam will
  REM  resume the victim system waiting for your attach command to stop it
  REM  again.

  SET  CAT_RESUME=

  REM  This variable allows ICAT to configure KDB with some of your favorite
  REM  commands.  An example would be CAT_KDB_INIT=vsf *     .  This would have
  REM  KDB trap back to ICAT when a fatal trap/fault occurs in a ring-3 app.
  REM  You can use multiple KDB commands separated by semicolons in the string.

  SET  CAT_KDB_INIT=

  REM  This variable allows ICAT to disconnect from debugee without restarting
  REM  debugee. This is useful reattaching to debuggee but not have the debuggee
  REM  run between attaches.

  SET  CAT_KEEP_KDB_ON_DETACH=

  REM  If either of the next two environment variables is defined, icatgam sets
  REM  up the COMx port provided by the CAT_MACHINE environment variable so
  REM  that icatgam can talk to a modem and issues the modem attention string
  REM  (+++).  If CAT_MODEM_INIT is defined, icatgam then sends the modem the
  REM  string contained in the CAT_MODEM_INIT environment variable.  If
  REM  CAT_DIAL is defined, icatgam then sends the modem the string contained
  REM  in the CAT_DIAL environment variable and waits 500 seconds for a
  REM  connection to be established.
  REM
  REM  Our intention is that you will figure out the magic AT commands for
  REM  CAT_MODEM_INIT based on whatever you currently use in your terminal
  REM  emulator (which presumably doesn't change very often).  You can then
  REM  leave CAT_MODEM_INIT alone and set CAT_DIAL to the command to actually
  REM  place the call (which presumably changes frequently).

  REM  SET  CAT_DIAL=ATDT4840

  REM  SET  CAT_MODEM_INIT=ATZ

rem call l:\bin\setenv.cmd
call c:\icat\bin\setenv.cmd
del c:\os2\*.@*
icatgam
endlocal


text:
SublimeKeyMap.Web
=================

A simple repository used to host / share my customized Sublime Text 2 key bindings for web plugins

Designed to be incorporated into `Package Control.sublime-settings` like:

```json
{
    "installed_packages":
    [
        "AngularJS (CoffeeScript)",
        "AutoFileName",
        "Chai Completions",
        "CoffeeComplete Plus (Autocompletion)",
        "DocBlockr",
        "Emmet",
        "Grunt",
        "Hayaku - tools for writing CSS faster",
        "HTML5",
        "jQuery",
        "LESS",
        "LiveReload",
        "Pretty JSON",
        "sublime-better-coffeescript",
        "SublimeLinter",
        "Tag",
        "Twitter Bootstrap Snippets"
    ],
    "package_name_map": {
      "SublimeKeyMap.Web": "ZZZ.EthanBrown.SublimeKeyMap.Web"
    },
    "repositories":
    [
        "https://github.com/Iristyle/SublimeKeyMap.Web",
        "https://github.com/Iristyle/SublimeLinter"
    ]
}
```


text:
Find in our site

<gcse:search></gcse:search>


text:
package org.jkiss.dbeaver.core.application.update;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.jkiss.dbeaver.DBeaverPreferences;
import org.jkiss.dbeaver.Log;
import org.jkiss.dbeaver.core.DBeaverCore;
import org.jkiss.dbeaver.core.DBeaverUI;
import org.jkiss.dbeaver.model.runtime.AbstractJob;
import org.jkiss.dbeaver.model.runtime.DBRProgressMonitor;
import org.jkiss.dbeaver.registry.updater.VersionDescriptor;
import org.jkiss.dbeaver.utils.GeneralUtils;

import java.io.IOException;
import java.util.Calendar;

/**
 * Version checker job
 */
public class DBeaverVersionChecker extends AbstractJob {

    private static final Log log = Log.getLog(DBeaverVersionChecker.class);

    private final boolean showAlways;

    public DBeaverVersionChecker(boolean force)
    {
        super("DBeaver new version release checker");
        this.showAlways = force;
    }

    @Override
    protected IStatus run(DBRProgressMonitor monitor)
    {
        if (monitor.isCanceled() || DBeaverCore.isClosing()) {
            return Status.CANCEL_STATUS;
        }
        boolean showUpdateDialog = showAlways;
        if (!showUpdateDialog) {
            // Check for auto-update settings
            showUpdateDialog = DBeaverCore.getGlobalPreferenceStore().getBoolean(DBeaverPreferences.UI_AUTO_UPDATE_CHECK);
            if (showUpdateDialog) {

                long lastVersionCheckTime = DBeaverCore.getGlobalPreferenceStore().getLong(DBeaverPreferences.UI_UPDATE_CHECK_TIME);
                if (lastVersionCheckTime > 0) {
                    // Do not check more often than daily
                    Calendar cal = Calendar.getInstance();
                    cal.setTimeInMillis(lastVersionCheckTime);
                    int checkMonth = cal.get(Calendar.MONTH);
                    int checkDay = cal.get(Calendar.DAY_OF_MONTH);
                    cal.setTimeInMillis(System.currentTimeMillis());
                    int curMonth = cal.get(Calendar.MONTH);
                    int curDay = cal.get(Calendar.DAY_OF_MONTH);
                    if (curMonth == checkMonth && curDay == checkDay) {
                        // Already checked today
                        return Status.OK_STATUS;
                    }
                }
            }
        }
        if (!showAlways && !showUpdateDialog) {
            return Status.OK_STATUS;
        }

        DBeaverCore.getGlobalPreferenceStore().setValue(DBeaverPreferences.UI_UPDATE_CHECK_TIME, System.currentTimeMillis());
        final String updateURL = Platform.getProduct().getProperty("versionUpdateURL");
        if (updateURL == null) {
            return Status.OK_STATUS;
        }
        VersionDescriptor versionDescriptor = null;
        try {
            versionDescriptor = new VersionDescriptor(updateURL);
        } catch (IOException e) {
            log.debug(e);
        }

        if (versionDescriptor != null && versionDescriptor.getProgramVersion().compareTo(GeneralUtils.getProductVersion()) > 0) {
            showUpdaterDialog(versionDescriptor);
        } else if (showAlways) {
            showUpdaterDialog(null);
        }

        return Status.OK_STATUS;
    }

    private void showUpdaterDialog(final VersionDescriptor versionDescriptor)
    {
        DBeaverUI.asyncExec(new Runnable() {
            @Override
            public void run() {
                VersionUpdateDialog dialog = new VersionUpdateDialog(
                    DBeaverUI.getActiveWorkbenchShell(),
                    versionDescriptor);
                dialog.open();
            }
        });
    }
}


text:
var assign = require('object-assign');
var NavButton = require('../native_react_views/NavButton');
var React = require('react-native');
var Routes = require('../constants/Routes');
var {
  ScrollView,
  StyleSheet,
  Text,
  TouchableHighlight,
  View,
} = React;

var AppStyles = require('../constants/AppStyles');
var AppViews = require('../native_react_views/AppViews');
var {
  HeaderSpacer,
} = AppViews;
var TerminalCardView = require('../native_react_views/TerminalCardView');
var NavButton = require('../native_react_views/NavButton');
var Levels = require('../../levels');

var intl = require('../intl');

var SequenceSelectView = React.createClass({

  propTypes: {
    navigator: React.PropTypes.object.isRequired,
  },

  render: function() {
    return (
      <View style={styles.background}>
        <HeaderSpacer />
        <ScrollView style={styles.container}>
          <View style={styles.headerSpacer} />
          <TerminalCardView>
            <View style={styles.terminalContainer}>
              {Object.keys(Levels.levelSequences).map(
                sequenceID => this.renderSelector(sequenceID)
              )}
            </View>
          </TerminalCardView>
        </ScrollView>
      </View>
    );
  },

  renderSelector: function(sequenceID) {
    var info = Levels.sequenceInfo[sequenceID];
    var name = intl.getIntlKey(info, 'displayName');
    var about = intl.getIntlKey(info, 'about');

    return (
      <TouchableHighlight
        onPress={() => {
          this.props.navigator.push(
            Routes.getRouteForID(Routes.LEVEL_SELECT)
          );
        }}
        underlayColor="#6E6E6E">
        <View>
          <View style={styles.textContainer}>
            <Text style={styles.sequenceName}>
              {name}
            </Text>
            <Text style={styles.sequenceAbout}>
              {about}
            </Text>
          </View>
          <View style={styles.divider} />
        </View>
      </TouchableHighlight>
    );
  }

});

var styles = StyleSheet.create({
  divider: {
    height: 1,
    marginBottom: 8,
    backgroundColor: '#FFF'
  },
  terminalContainer: {
    paddingTop: 8,
    paddingBottom: 8,
  },
  textContainer: {
    paddingLeft: 8,
    paddingRight: 8,
  },
  sequenceName: assign({}, AppStyles.terminalTextStyle, {
    fontSize: 20,
  }),
  sequenceAbout: assign({}, AppStyles.terminalTextStyle, {
    fontSize: 10,
    marginTop: 8,
    marginBottom: 8,
  }),
  container: {
    padding: 8,
  },
  headerSpacer: {
    height: 24,
  },
  background: {
    backgroundColor: AppStyles.blueBackground,
    flex: 1
  },
});

module.exports = SequenceSelectView;


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  Copyright (c) 2012 Manning
  See the file license.txt for copying permission.
-->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical" >

    <include layout="@layout/header" />

    <TextView
        android:id="@+id/label"
        style="@android:style/TextAppearance.Large"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" />

</LinearLayout>


text:
<?xml version="1.0" encoding="UTF-8"?>
<class access="public" id="class:jsx3.chart.Axis" name="jsx3.chart.Axis" package="jsx3.chart" shortname="Axis">
  <text>A base class for all types of axis. Provides all the common properties as well as all rendering
logic. Rendering relies on template methods implemented in concrete subclasses.

An axis renders in the following location based on its horizontal and primary properties:

  horizontal x primary   -> bottom
  vertical x primary     -> left
  horizontal x secondary -> top
  vertical x secondary   -> right

 </text>
  <superclass id="super:0" loaded="1" name="Object"/>
  <superclass id="super:1" loaded="1" name="jsx3.lang.Object"/>
  <superclass id="super:2" loaded="1" name="jsx3.app.Model"/>
  <superclass id="super:3" loaded="1" name="jsx3.gui.Painted"/>
  <superclass id="super:4" loaded="1" name="jsx3.gui.Block"/>
  <superclass direct="1" id="super:5" loaded="1" name="jsx3.chart.ChartComponent"/>
  <implements id="implements:0" loaded="1" name="jsx3.gui.Interactive"/>
  <implements id="implements:1" loaded="1" name="jsx3.util.EventDispatcher"/>
  <subclass id="sub:0" loaded="1" name="jsx3.chart.CategoryAxis"/>
  <subclass id="sub:1" loaded="1" name="jsx3.chart.LinearAxis"/>
  <subclass id="sub:2" loaded="1" name="jsx3.chart.LogarithmicAxis"/>
  <field access="public" class="jsx3.chart.Axis" final="1" fullname="jsx3.chart.Axis.TICK_INSIDE" id="sfield:TICK_INSIDE" name="TICK_INSIDE" static="1" value=""inside"">
    <type link="1" name="String"/>
  </field>
  <field access="public" class="jsx3.chart.Axis" final="1" fullname="jsx3.chart.Axis.TICK_OUTSIDE" id="sfield:TICK_OUTSIDE" name="TICK_OUTSIDE" static="1" value=""outside"">
    <type link="1" name="String"/>
  </field>
  <field access="public" class="jsx3.chart.Axis" final="1" fullname="jsx3.chart.Axis.TICK_CROSS" id="sfield:TICK_CROSS" name="TICK_CROSS" static="1" value=""cross"">
    <type link="1" name="String"/>
  </field>
  <field access="public" class="jsx3.chart.Axis" final="1" fullname="jsx3.chart.Axis.TICK_NONE" id="sfield:TICK_NONE" name="TICK_NONE" static="1" value=""none"">
    <type link="1" name="String"/>
  </field>
  <field access="public" class="jsx3.chart.Axis" final="1" fullname="jsx3.chart.Axis.LABEL_HIGH" id="sfield:LABEL_HIGH" name="LABEL_HIGH" static="1" value=""high"">
    <type link="1" name="String"/>
  </field>
  <field access="public" class="jsx3.chart.Axis" final="1" fullname="jsx3.chart.Axis.LABEL_LOW" id="sfield:LABEL_LOW" name="LABEL_LOW" static="1" value=""low"">
    <type link="1" name="String"/>
  </field>
  <field access="public" class="jsx3.chart.Axis" final="1" fullname="jsx3.chart.Axis.LABEL_AXIS" id="sfield:LABEL_AXIS" name="LABEL_AXIS" static="1" value=""axis"">
    <type link="1" name="String"/>
  </field>
  <method access="public" id="smethod:percent" name="percent" static="1">
    <param name="v" text="">
      <type link="1" name="Number"/>
    </param>
    <return text="">
      <type link="1" name="String"/>
    </return>
    <text>formats labels as a percent, ie "50%"</text>
  </method>
  <method access="public" id="smethod:scientific" name="scientific" static="1">
    <param name="v" text="">
      <type link="1" name="Number"/>
    </param>
    <param name="signif" text="">
      <type class="Number" link="1" name="int"/>
    </param>
    <return text="">
      <type link="1" name="String"/>
    </return>
    <text>formats labels in scientific notation, ie "5e2"</text>
  </method>
  <constructor access="public" id="method:init" name="init">
    <param name="name" text="the GI name of the instance">
      <type link="1" name="String"/>
    </param>
    <param name="horizontal" text="whether this axis is horizontal (x), otherwise it's vertical (y)">
      <type class="Boolean" link="1" name="boolean"/>
    </param>
    <param name="primary" text="whether this axis is primary, otherwise it's secondary
   ">
      <type class="Boolean" link="1" name="boolean"/>
    </param>
    <text>The instance initializer.</text>
  </constructor>
  <method access="public" id="method:getHorizontal" name="getHorizontal">
    <return text="horizontal
   ">
      <type class="Boolean" link="1" name="boolean"/>
    </return>
    <text>Returns the horizontal field, whether this is an x axis, otherwise it is a y axis.</text>
  </method>
  <method access="public" id="method:setHorizontal" name="setHorizontal">
    <param name="horizontal" text="the new value for horizontal
   ">
      <type class="Boolean" link="1" name="boolean"/>
    </param>
    <text>Sets the horizontal field.</text>
  </method>
  <method access="public" id="method:getShowAxis" name="getShowAxis">
    <return text="showAxis
   ">
      <type class="Boolean" link="1" name="boolean"/>
    </return>
    <text>Returns the showAxis field, whether to show the line along the axis.</text>
  </method>
  <method access="public" id="method:setShowAxis" name="setShowAxis">
    <param name="showAxis" text="the new value for showAxis
   ">
      <type class="Boolean" link="1" name="boolean"/>
    </param>
    <text>Sets the showAxis field.</text>
  </method>
  <method access="public" id="method:getLabelFunction" name="getLabelFunction">
    <return text="labelFunction
   ">
      <type link="1" name="Function"/>
    </return>
    <text>Returns the labelFunction field.</text>
  </method>
  <method access="public" id="method:setLabelFunction" name="setLabelFunction">
    <param name="labelFunction" text="the new value for labelFunction, a function with the signature
    <code>function(value : Number|String) : String</code>.
   ">
      <type link="1" name="String"/>
      <type link="1" name="Function"/>
    </param>
    <text>Sets the labelFunction field, allows for formatting and transformation of a major tick label.
The function will be applied to this object when called.
Note that passing a function reference to this method will prevent the value from being persisted if this
object is serialized.</text>
  </method>
  <method access="public" id="method:getAxisStroke" name="getAxisStroke">
    <return text="axisStroke
   ">
      <type link="1" name="String"/>
    </return>
    <text>Returns the axisStroke field, string representation of the VectorStroke used to draw the line of the axis.</text>
  </method>
  <method access="public" id="method:setAxisStroke" name="setAxisStroke">
    <param name="axisStroke" text="the new value for axisStroke
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the axisStroke field.</text>
  </method>
  <method access="public" id="method:getShowLabels" name="getShowLabels">
    <return text="showLabels
   ">
      <type class="Boolean" link="1" name="boolean"/>
    </return>
    <text>Returns the showLabels field, whether to show major tick labels.</text>
  </method>
  <method access="public" id="method:setShowLabels" name="setShowLabels">
    <param name="showLabels" text="the new value for showLabels
   ">
      <type class="Boolean" link="1" name="boolean"/>
    </param>
    <text>Sets the showLabels field.</text>
  </method>
  <method access="public" id="method:getLabelGap" name="getLabelGap">
    <return text="labelGap
   ">
      <type class="Number" link="1" name="int"/>
    </return>
    <text>Returns the labelGap field, the pixel gap between the tick lines and the labels.</text>
  </method>
  <method access="public" id="method:setLabelGap" name="setLabelGap">
    <param name="labelGap" text="the new value for labelGap
   ">
      <type class="Number" link="1" name="int"/>
    </param>
    <text>Sets the labelGap field.</text>
  </method>
  <method access="public" id="method:setLabelPlacement" name="setLabelPlacement">
    <param name="labelPlacement" text="the new value for labelPlacement, one of {'axis','high','low'}
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the labelPlacement field, checks for invalid values.</text>
  </method>
  <method access="public" id="method:getTickLength" name="getTickLength">
    <return text="tickLength
   ">
      <type class="Number" link="1" name="int"/>
    </return>
    <text>Returns the tickLength field, the length in pixels of the major tick (if tickPlacement is "cross" the length will actually be twice this.</text>
  </method>
  <method access="public" id="method:setTickLength" name="setTickLength">
    <param name="tickLength" text="the new value for tickLength
   ">
      <type class="Number" link="1" name="int"/>
    </param>
    <text>Sets the tickLength field.</text>
  </method>
  <method access="public" id="method:getTickPlacement" name="getTickPlacement">
    <return text="tickPlacement, one of {'none','inside','outside','cross'}
   ">
      <type link="1" name="String"/>
    </return>
    <text>Returns the tickPlacement field, where to place the major ticks.</text>
  </method>
  <method access="public" id="method:setTickPlacement" name="setTickPlacement">
    <param name="tickPlacement" text="the new value for tickPlacement, one of {'none','inside','outside','cross'}
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the tickPlacement field.</text>
  </method>
  <method access="public" id="method:getTickStroke" name="getTickStroke">
    <return text="tickStroke
   ">
      <type link="1" name="String"/>
    </return>
    <text>Returns the tickStroke field, string representation of VectorStroke used to draw major ticks.</text>
  </method>
  <method access="public" id="method:setTickStroke" name="setTickStroke">
    <param name="tickStroke" text="the new value for tickStroke
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the tickStroke field.</text>
  </method>
  <method access="public" id="method:getMinorTickDivisions" name="getMinorTickDivisions">
    <return text="minorTickDivisions
   ">
      <type class="Number" link="1" name="int"/>
    </return>
    <text>Returns the minorTickDivisions field, number of minor tick divisions between major ticks; the number of minor ticks drawn will be this number minus 1.</text>
  </method>
  <method access="public" id="method:setMinorTickDivisions" name="setMinorTickDivisions">
    <param name="minorTickDivisions" text="the new value for minorTickDivisions
   ">
      <type class="Number" link="1" name="int"/>
    </param>
    <text>Sets the minorTickDivisions field.</text>
  </method>
  <method access="public" id="method:getMinorTickLength" name="getMinorTickLength">
    <return text="minorTickLength
   ">
      <type class="Number" link="1" name="int"/>
    </return>
    <text>Returns the minorTickLength field, the length in pixels of the minor tick (if tickPlacement is "cross" the length will actually be twice this.</text>
  </method>
  <method access="public" id="method:setMinorTickLength" name="setMinorTickLength">
    <param name="minorTickLength" text="the new value for minorTickLength
   ">
      <type class="Number" link="1" name="int"/>
    </param>
    <text>Sets the minorTickLength field.</text>
  </method>
  <method access="public" id="method:getMinorTickPlacement" name="getMinorTickPlacement">
    <return text="minorTickPlacement, one of {'none','inside','outside','cross'}
   ">
      <type link="1" name="String"/>
    </return>
    <text>Returns the minorTickPlacement field, where to place the minor ticks.</text>
  </method>
  <method access="public" id="method:setMinorTickPlacement" name="setMinorTickPlacement">
    <param name="minorTickPlacement" text="the new value for minorTickPlacement, one of {'none','inside','outside','cross'}
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the minorTickPlacement field.</text>
  </method>
  <method access="public" id="method:getMinorTickStroke" name="getMinorTickStroke">
    <return text="minorTickStroke
   ">
      <type link="1" name="String"/>
    </return>
    <text>Returns the minorTickStroke field, string representation of VectorStroke used to draw minor ticks.</text>
  </method>
  <method access="public" id="method:setMinorTickStroke" name="setMinorTickStroke">
    <param name="minorTickStroke" text="the new value for minorTickStroke
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the minorTickStroke field.</text>
  </method>
  <method access="public" id="method:getLabelClass" name="getLabelClass">
    <return text="labelClass
   ">
      <type link="1" name="String"/>
    </return>
    <text>Returns the labelClass field, the CSS class used to render major tick labels.</text>
  </method>
  <method access="public" id="method:setLabelClass" name="setLabelClass">
    <param name="labelClass" text="the new value for labelClass
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the labelClass field.</text>
  </method>
  <method access="public" id="method:getLabelStyle" name="getLabelStyle">
    <return text="labelStyle
   ">
      <type link="1" name="String"/>
    </return>
    <text>Returns the labelStyle field, the CSS style attribute used to render major tick labels.</text>
  </method>
  <method access="public" id="method:setLabelStyle" name="setLabelStyle">
    <param name="labelStyle" text="the new value for labelStyle
   ">
      <type link="1" name="String"/>
    </param>
    <text>Sets the labelStyle field.</text>
  </method>
  <method access="public" id="method:getLabelColor" name="getLabelColor">
    <return text="labelColor
   ">
      <type link="1" name="String"/>
      <type link="1" name="Number"/>
    </return>
    <text>Returns the labelColor field, the RGB color value of the label font; note that this is the only way to set the color of the text, using a CSS style attribute will have no effect.</text>
  </method>
  <method access="public" id="method:setLabelColor" name="setLabelColor">
    <param name="labelColor" text="the new value for labelColor
   ">
      <type link="1" name="String"/>
      <type link="1" name="Number"/>
    </param>
    <text>Sets the labelColor field.</text>
  </method>
  <method access="public" id="method:getDisplayWidth" name="getDisplayWidth">
    <return text="displayWidth
   ">
      <type class="Number" link="1" name="int"/>
    </return>
    <text>Returns the display width, the maximum amount of space perpendicular to the axis and outside of the data area that the ticks and labels may occupy (doesn't include area given to axis title).</text>
  </method>
  <method access="public" id="method:setDisplayWidth" name="setDisplayWidth">
    <param name="displayWidth" text="the new value for displayWidth
   ">
      <type class="Number" link="1" name="int"/>
    </param>
    <text>Sets the displayWidth field.</text>
  </method>
  <method access="public" id="method:getAxisTitle" name="getAxisTitle">
    <return text="">
      <type link="1" name="jsx3.chart.ChartLabel"/>
    </return>
    <text>Returns the optional jsx3.chart.ChartLabel child.</text>
  </method>
  <method access="public" id="method:getOpposingAxis" name="getOpposingAxis">
    <return text="">
      <type link="1" name="jsx3.chart.Axis"/>
    </return>
    <text>Returns the opposing axis.</text>
  </method>
  <method access="public" deprecated="1" id="smethod:getVersion" name="getVersion" static="1">
    <return text="">
      <type link="1" name="String"/>
    </return>
    <text>Returns the release/build for the class (i.e., "2.2.00").</text>
  </method>
  <method id="method:getChart" idfk="method:getChart" inherited="1" name="getChart" source="jsx3.chart.ChartComponent"/>
  <method id="method:getBackground" idfk="method:getBackground" inherited="1" name="getBackground" source="jsx3.gui.Block"/>
  <method id="method:getBackgroundColor" idfk="method:getBackgroundColor" inherited="1" name="getBackgroundColor" source="jsx3.gui.Block"/>
  <method id="method:getBorder" idfk="method:getBorder" inherited="1" name="getBorder" source="jsx3.gui.Block"/>
  <method id="method:getCDFAttribute" idfk="method:getCDFAttribute" inherited="1" name="getCDFAttribute" source="jsx3.gui.Block"/>
  <method id="method:getCDFId" idfk="method:getCDFId" inherited="1" name="getCDFId" source="jsx3.gui.Block"/>
  <method id="method:getCSSOverride" idfk="method:getCSSOverride" inherited="1" name="getCSSOverride" source="jsx3.gui.Block"/>
  <method id="method:getClassName" idfk="method:getClassName" inherited="1" name="getClassName" source="jsx3.gui.Block"/>
  <method id="method:getColor" idfk="method:getColor" inherited="1" name="getColor" source="jsx3.gui.Block"/>
  <method id="method:getCursor" idfk="method:getCursor" inherited="1" name="getCursor" source="jsx3.gui.Block"/>
  <method id="method:getDimensions" idfk="method:getDimensions" inherited="1" name="getDimensions" source="jsx3.gui.Block"/>
  <method id="method:getDisplay" idfk="method:getDisplay" inherited="1" name="getDisplay" source="jsx3.gui.Block"/>
  <method id="method:getFontName" idfk="method:getFontName" inherited="1" name="getFontName" source="jsx3.gui.Block"/>
  <method id="method:getFontSize" idfk="method:getFontSize" inherited="1" name="getFontSize" source="jsx3.gui.Block"/>
  <method id="method:getFontWeight" idfk="method:getFontWeight" inherited="1" name="getFontWeight" source="jsx3.gui.Block"/>
  <method id="method:getHeight" idfk="method:getHeight" inherited="1" name="getHeight" source="jsx3.gui.Block"/>
  <method id="method:getIndex" idfk="method:getIndex" inherited="1" name="getIndex" source="jsx3.gui.Block"/>
  <method id="method:getLeft" idfk="method:getLeft" inherited="1" name="getLeft" source="jsx3.gui.Block"/>
  <method id="method:getMargin" idfk="method:getMargin" inherited="1" name="getMargin" source="jsx3.gui.Block"/>
  <method id="method:getOverflow" idfk="method:getOverflow" inherited="1" name="getOverflow" source="jsx3.gui.Block"/>
  <method id="method:getPadding" idfk="method:getPadding" inherited="1" name="getPadding" source="jsx3.gui.Block"/>
  <method id="method:getRelativePosition" idfk="method:getRelativePosition" inherited="1" name="getRelativePosition" source="jsx3.gui.Block"/>
  <method id="method:getTagName" idfk="method:getTagName" inherited="1" name="getTagName" source="jsx3.gui.Block"/>
  <method id="method:getText" idfk="method:getText" inherited="1" name="getText" source="jsx3.gui.Block"/>
  <method id="method:getTextAlign" idfk="method:getTextAlign" inherited="1" name="getTextAlign" source="jsx3.gui.Block"/>
  <method id="method:getTip" idfk="method:getTip" inherited="1" name="getTip" source="jsx3.gui.Block"/>
  <method id="method:getTop" idfk="method:getTop" inherited="1" name="getTop" source="jsx3.gui.Block"/>
  <method id="method:getVisibility" idfk="method:getVisibility" inherited="1" name="getVisibility" source="jsx3.gui.Block"/>
  <method id="method:getWidth" idfk="method:getWidth" inherited="1" name="getWidth" source="jsx3.gui.Block"/>
  <method id="method:getZIndex" idfk="method:getZIndex" inherited="1" name="getZIndex" source="jsx3.gui.Block"/>
  <method id="method:hideMask" idfk="method:hideMask" inherited="1" name="hideMask" source="jsx3.gui.Block"/>
  <method id="method:paint" idfk="method:paint" inherited="1" name="paint" source="jsx3.gui.Block"/>
  <method id="method:setBackground" idfk="method:setBackground" inherited="1" name="setBackground" source="jsx3.gui.Block"/>
  <method id="method:setBackgroundColor" idfk="method:setBackgroundColor" inherited="1" name="setBackgroundColor" source="jsx3.gui.Block"/>
  <method id="method:setBorder" idfk="method:setBorder" inherited="1" name="setBorder" source="jsx3.gui.Block"/>
  <method id="method:setCDFAttribute" idfk="method:setCDFAttribute" inherited="1" name="setCDFAttribute" source="jsx3.gui.Block"/>
  <method id="method:setCDFId" idfk="method:setCDFId" inherited="1" name="setCDFId" source="jsx3.gui.Block"/>
  <method id="method:setCSSOverride" idfk="method:setCSSOverride" inherited="1" name="setCSSOverride" source="jsx3.gui.Block"/>
  <method id="method:setClassName" idfk="method:setClassName" inherited="1" name="setClassName" source="jsx3.gui.Block"/>
  <method id="method:setColor" idfk="method:setColor" inherited="1" name="setColor" source="jsx3.gui.Block"/>
  <method id="method:setCursor" idfk="method:setCursor" inherited="1" name="setCursor" source="jsx3.gui.Block"/>
  <method id="method:setDimensions" idfk="method:setDimensions" inherited="1" name="setDimensions" source="jsx3.gui.Block"/>
  <method id="method:setDisplay" idfk="method:setDisplay" inherited="1" name="setDisplay" source="jsx3.gui.Block"/>
  <method id="method:setFontName" idfk="method:setFontName" inherited="1" name="setFontName" source="jsx3.gui.Block"/>
  <method id="method:setFontSize" idfk="method:setFontSize" inherited="1" name="setFontSize" source="jsx3.gui.Block"/>
  <method id="method:setFontWeight" idfk="method:setFontWeight" inherited="1" name="setFontWeight" source="jsx3.gui.Block"/>
  <method id="method:setHeight" idfk="method:setHeight" inherited="1" name="setHeight" source="jsx3.gui.Block"/>
  <method id="method:setIndex" idfk="method:setIndex" inherited="1" name="setIndex" source="jsx3.gui.Block"/>
  <method id="method:setLeft" idfk="method:setLeft" inherited="1" name="setLeft" source="jsx3.gui.Block"/>
  <method id="method:setMargin" idfk="method:setMargin" inherited="1" name="setMargin" source="jsx3.gui.Block"/>
  <method id="method:setOverflow" idfk="method:setOverflow" inherited="1" name="setOverflow" source="jsx3.gui.Block"/>
  <method id="method:setPadding" idfk="method:setPadding" inherited="1" name="setPadding" source="jsx3.gui.Block"/>
  <method id="method:setRelativePosition" idfk="method:setRelativePosition" inherited="1" name="setRelativePosition" source="jsx3.gui.Block"/>
  <method id="method:setTagName" idfk="method:setTagName" inherited="1" name="setTagName" source="jsx3.gui.Block"/>
  <method id="method:setText" idfk="method:setText" inherited="1" name="setText" source="jsx3.gui.Block"/>
  <method id="method:setTextAlign" idfk="method:setTextAlign" inherited="1" name="setTextAlign" source="jsx3.gui.Block"/>
  <method id="method:setTip" idfk="method:setTip" inherited="1" name="setTip" source="jsx3.gui.Block"/>
  <method id="method:setTop" idfk="method:setTop" inherited="1" name="setTop" source="jsx3.gui.Block"/>
  <method id="method:setVisibility" idfk="method:setVisibility" inherited="1" name="setVisibility" source="jsx3.gui.Block"/>
  <method id="method:setWidth" idfk="method:setWidth" inherited="1" name="setWidth" source="jsx3.gui.Block"/>
  <method id="method:setZIndex" idfk="method:setZIndex" inherited="1" name="setZIndex" source="jsx3.gui.Block"/>
  <method id="method:showMask" idfk="method:showMask" inherited="1" name="showMask" source="jsx3.gui.Block"/>
  <method id="method:doEvent" idfk="method:doEvent" inherited="1" name="doEvent" source="jsx3.gui.Interactive"/>
  <method id="method:getCanDrag" idfk="method:getCanDrag" inherited="1" name="getCanDrag" source="jsx3.gui.Interactive"/>
  <method id="method:getCanDrop" idfk="method:getCanDrop" inherited="1" name="getCanDrop" source="jsx3.gui.Interactive"/>
  <method id="method:getCanMove" idfk="method:getCanMove" inherited="1" name="getCanMove" source="jsx3.gui.Interactive"/>
  <method id="method:getCanSpy" idfk="method:getCanSpy" inherited="1" name="getCanSpy" source="jsx3.gui.Interactive"/>
  <method id="method:getEvent" idfk="method:getEvent" inherited="1" name="getEvent" source="jsx3.gui.Interactive"/>
  <method id="method:getEvents" idfk="method:getEvents" inherited="1" name="getEvents" source="jsx3.gui.Interactive"/>
  <method id="method:getMenu" idfk="method:getMenu" inherited="1" name="getMenu" source="jsx3.gui.Interactive"/>
  <method id="method:hasEvent" idfk="method:hasEvent" inherited="1" name="hasEvent" source="jsx3.gui.Interactive"/>
  <method id="method:registerHotKey" idfk="method:registerHotKey" inherited="1" name="registerHotKey" source="jsx3.gui.Interactive"/>
  <method id="method:removeEvent" idfk="method:removeEvent" inherited="1" name="removeEvent" source="jsx3.gui.Interactive"/>
  <method id="method:removeEvents" idfk="method:removeEvents" inherited="1" name="removeEvents" source="jsx3.gui.Interactive"/>
  <method id="method:setCanDrag" idfk="method:setCanDrag" inherited="1" name="setCanDrag" source="jsx3.gui.Interactive"/>
  <method id="method:setCanDrop" idfk="method:setCanDrop" inherited="1" name="setCanDrop" source="jsx3.gui.Interactive"/>
  <method id="method:setCanMove" idfk="method:setCanMove" inherited="1" name="setCanMove" source="jsx3.gui.Interactive"/>
  <method id="method:setCanSpy" idfk="method:setCanSpy" inherited="1" name="setCanSpy" source="jsx3.gui.Interactive"/>
  <method id="method:setEvent" idfk="method:setEvent" inherited="1" name="setEvent" source="jsx3.gui.Interactive"/>
  <method id="method:setMenu" idfk="method:setMenu" inherited="1" name="setMenu" source="jsx3.gui.Interactive"/>
  <method id="method:setSpyStyles" idfk="method:setSpyStyles" inherited="1" name="setSpyStyles" source="jsx3.gui.Interactive"/>
  <method id="method:showSpy" idfk="method:showSpy" inherited="1" name="showSpy" source="jsx3.gui.Interactive"/>
  <method id="method:focus" idfk="method:focus" inherited="1" name="focus" source="jsx3.gui.Painted"/>
  <method id="method:getAbsolutePosition" idfk="method:getAbsolutePosition" inherited="1" name="getAbsolutePosition" source="jsx3.gui.Painted"/>
  <method id="method:getAttribute" idfk="method:getAttribute" inherited="1" name="getAttribute" source="jsx3.gui.Painted"/>
  <method id="method:getAttributes" idfk="method:getAttributes" inherited="1" name="getAttributes" source="jsx3.gui.Painted"/>
  <method id="method:getDynamicProperty" idfk="method:getDynamicProperty" inherited="1" name="getDynamicProperty" source="jsx3.gui.Painted"/>
  <method id="method:getRendered" idfk="method:getRendered" inherited="1" name="getRendered" source="jsx3.gui.Painted"/>
  <method deprecated="1" id="method:insertHTML" idfk="method:insertHTML" inherited="1" name="insertHTML" source="jsx3.gui.Painted"/>
  <method id="method:onAfterPaint" idfk="method:onAfterPaint" inherited="1" name="onAfterPaint" source="jsx3.gui.Painted"/>
  <method id="method:onAfterRestoreView" idfk="method:onAfterRestoreView" inherited="1" name="onAfterRestoreView" source="jsx3.gui.Painted"/>
  <method id="method:paintChild" idfk="method:paintChild" inherited="1" name="paintChild" source="jsx3.gui.Painted"/>
  <method id="method:paintChildren" idfk="method:paintChildren" inherited="1" name="paintChildren" source="jsx3.gui.Painted"/>
  <method id="method:recalcBox" idfk="method:recalcBox" inherited="1" name="recalcBox" source="jsx3.gui.Painted"/>
  <method id="method:removeAttribute" idfk="method:removeAttribute" inherited="1" name="removeAttribute" source="jsx3.gui.Painted"/>
  <method id="method:removeAttributes" idfk="method:removeAttributes" inherited="1" name="removeAttributes" source="jsx3.gui.Painted"/>
  <method id="method:repaint" idfk="method:repaint" inherited="1" name="repaint" source="jsx3.gui.Painted"/>
  <method id="method:setAttribute" idfk="method:setAttribute" inherited="1" name="setAttribute" source="jsx3.gui.Painted"/>
  <method id="method:setDynamicProperty" idfk="method:setDynamicProperty" inherited="1" name="setDynamicProperty" source="jsx3.gui.Painted"/>
  <method id="method:adoptChild" idfk="method:adoptChild" inherited="1" name="adoptChild" source="jsx3.app.Model"/>
  <method id="method:doClone" idfk="method:doClone" inherited="1" name="doClone" source="jsx3.app.Model"/>
  <method id="method:findAncestor" idfk="method:findAncestor" inherited="1" name="findAncestor" source="jsx3.app.Model"/>
  <method id="method:findDescendants" idfk="method:findDescendants" inherited="1" name="findDescendants" source="jsx3.app.Model"/>
  <method id="method:getAncestorOfName" idfk="method:getAncestorOfName" inherited="1" name="getAncestorOfName" source="jsx3.app.Model"/>
  <method id="method:getAncestorOfType" idfk="method:getAncestorOfType" inherited="1" name="getAncestorOfType" source="jsx3.app.Model"/>
  <method id="method:getChild" idfk="method:getChild" inherited="1" name="getChild" source="jsx3.app.Model"/>
  <method id="method:getChildIndex" idfk="method:getChildIndex" inherited="1" name="getChildIndex" source="jsx3.app.Model"/>
  <method id="method:getChildren" idfk="method:getChildren" inherited="1" name="getChildren" source="jsx3.app.Model"/>
  <method id="method:getDescendantOfName" idfk="method:getDescendantOfName" inherited="1" name="getDescendantOfName" source="jsx3.app.Model"/>
  <method id="method:getDescendantsOfType" idfk="method:getDescendantsOfType" inherited="1" name="getDescendantsOfType" source="jsx3.app.Model"/>
  <method id="method:getFirstChild" idfk="method:getFirstChild" inherited="1" name="getFirstChild" source="jsx3.app.Model"/>
  <method id="method:getFirstChildOfType" idfk="method:getFirstChildOfType" inherited="1" name="getFirstChildOfType" source="jsx3.app.Model"/>
  <method id="method:getHelpId" idfk="method:getHelpId" inherited="1" name="getHelpId" source="jsx3.app.Model"/>
  <method id="method:getId" idfk="method:getId" inherited="1" name="getId" source="jsx3.app.Model"/>
  <method id="method:getLastChild" idfk="method:getLastChild" inherited="1" name="getLastChild" source="jsx3.app.Model"/>
  <method id="method:getLoadType" idfk="method:getLoadType" inherited="1" name="getLoadType" source="jsx3.app.Model"/>
  <method id="method:getMetaValue" idfk="method:getMetaValue" inherited="1" name="getMetaValue" source="jsx3.app.Model"/>
  <method id="method:getNS" idfk="method:getNS" inherited="1" name="getNS" source="jsx3.app.Model"/>
  <method id="method:getName" idfk="method:getName" inherited="1" name="getName" source="jsx3.app.Model"/>
  <method id="method:getNextSibling" idfk="method:getNextSibling" inherited="1" name="getNextSibling" source="jsx3.app.Model"/>
  <method final="1" id="method:getParent" idfk="method:getParent" inherited="1" name="getParent" source="jsx3.app.Model"/>
  <method id="method:getPersistence" idfk="method:getPersistence" inherited="1" name="getPersistence" source="jsx3.app.Model"/>
  <method id="method:getPreviousSibling" idfk="method:getPreviousSibling" inherited="1" name="getPreviousSibling" source="jsx3.app.Model"/>
  <method id="method:getServer" idfk="method:getServer" inherited="1" name="getServer" source="jsx3.app.Model"/>
  <method id="method:getUriResolver" idfk="method:getUriResolver" inherited="1" name="getUriResolver" source="jsx3.app.Model"/>
  <method id="method:insertBefore" idfk="method:insertBefore" inherited="1" name="insertBefore" source="jsx3.app.Model"/>
  <method id="method:load" idfk="method:load" inherited="1" name="load" source="jsx3.app.Model"/>
  <method id="method:loadAndCache" idfk="method:loadAndCache" inherited="1" name="loadAndCache" source="jsx3.app.Model"/>
  <method id="method:loadXML" idfk="method:loadXML" inherited="1" name="loadXML" source="jsx3.app.Model"/>
  <method id="method:onAfterAssemble" idfk="method:onAfterAssemble" inherited="1" name="onAfterAssemble" source="jsx3.app.Model"/>
  <method id="method:onAfterAttach" idfk="method:onAfterAttach" inherited="1" name="onAfterAttach" source="jsx3.app.Model"/>
  <method id="method:onBeforeAssemble" idfk="method:onBeforeAssemble" inherited="1" name="onBeforeAssemble" source="jsx3.app.Model"/>
  <method id="method:onChangeServer" idfk="method:onChangeServer" inherited="1" name="onChangeServer" source="jsx3.app.Model"/>
  <method id="method:onChildAdded" idfk="method:onChildAdded" inherited="1" name="onChildAdded" source="jsx3.app.Model"/>
  <method id="method:onDestroy" idfk="method:onDestroy" inherited="1" name="onDestroy" source="jsx3.app.Model"/>
  <method id="method:onRemoveChild" idfk="method:onRemoveChild" inherited="1" name="onRemoveChild" source="jsx3.app.Model"/>
  <method id="method:onSetChild" idfk="method:onSetChild" inherited="1" name="onSetChild" source="jsx3.app.Model"/>
  <method id="method:onSetParent" idfk="method:onSetParent" inherited="1" name="onSetParent" source="jsx3.app.Model"/>
  <method id="method:removeChild" idfk="method:removeChild" inherited="1" name="removeChild" source="jsx3.app.Model"/>
  <method id="method:removeChildren" idfk="method:removeChildren" inherited="1" name="removeChildren" source="jsx3.app.Model"/>
  <method id="method:selectDescendants" idfk="method:selectDescendants" inherited="1" name="selectDescendants" source="jsx3.app.Model"/>
  <method id="method:setChild" idfk="method:setChild" inherited="1" name="setChild" source="jsx3.app.Model"/>
  <method id="method:setHelpId" idfk="method:setHelpId" inherited="1" name="setHelpId" source="jsx3.app.Model"/>
  <method id="method:setLoadType" idfk="method:setLoadType" inherited="1" name="setLoadType" source="jsx3.app.Model"/>
  <method id="method:setMetaValue" idfk="method:setMetaValue" inherited="1" name="setMetaValue" source="jsx3.app.Model"/>
  <method id="method:setName" idfk="method:setName" inherited="1" name="setName" source="jsx3.app.Model"/>
  <method id="method:setPersistence" idfk="method:setPersistence" inherited="1" name="setPersistence" source="jsx3.app.Model"/>
  <method id="method:toString" idfk="method:toString" inherited="1" name="toString" source="jsx3.app.Model"/>
  <method id="method:toXML" idfk="method:toXML" inherited="1" name="toXML" source="jsx3.app.Model"/>
  <method id="method:toXMLDoc" idfk="method:toXMLDoc" inherited="1" name="toXMLDoc" source="jsx3.app.Model"/>
  <method id="method:publish" idfk="method:publish" inherited="1" name="publish" source="jsx3.util.EventDispatcher"/>
  <method id="method:subscribe" idfk="method:subscribe" inherited="1" name="subscribe" source="jsx3.util.EventDispatcher"/>
  <method id="method:unsubscribe" idfk="method:unsubscribe" inherited="1" name="unsubscribe" source="jsx3.util.EventDispatcher"/>
  <method id="method:unsubscribeAll" idfk="method:unsubscribeAll" inherited="1" name="unsubscribeAll" source="jsx3.util.EventDispatcher"/>
  <method id="method:clone" idfk="method:clone" inherited="1" name="clone" source="jsx3.lang.Object"/>
  <method id="method:equals" idfk="method:equals" inherited="1" name="equals" source="jsx3.lang.Object"/>
  <method id="method:eval" idfk="method:eval" inherited="1" name="eval" source="jsx3.lang.Object"/>
  <method id="method:getClass" idfk="method:getClass" inherited="1" name="getClass" source="jsx3.lang.Object"/>
  <method deprecated="1" id="method:getInstanceOf" idfk="method:getInstanceOf" inherited="1" name="getInstanceOf" source="jsx3.lang.Object"/>
  <method deprecated="1" id="method:getInstanceOfClass" idfk="method:getInstanceOfClass" inherited="1" name="getInstanceOfClass" source="jsx3.lang.Object"/>
  <method deprecated="1" id="method:getInstanceOfPackage" idfk="method:getInstanceOfPackage" inherited="1" name="getInstanceOfPackage" source="jsx3.lang.Object"/>
  <method id="method:instanceOf" idfk="method:instanceOf" inherited="1" name="instanceOf" source="jsx3.lang.Object"/>
  <method deprecated="1" id="method:isInstanceOf" idfk="method:isInstanceOf" inherited="1" name="isInstanceOf" source="jsx3.lang.Object"/>
  <method deprecated="1" id="method:isSubclassOf" idfk="method:isSubclassOf" inherited="1" name="isSubclassOf" source="jsx3.lang.Object"/>
  <method deprecated="1" id="method:jsxmix" idfk="method:jsxmix" inherited="1" name="jsxmix" source="jsx3.lang.Object"/>
  <method id="method:jsxsuper" idfk="method:jsxsuper" inherited="1" name="jsxsuper" source="jsx3.lang.Object"/>
  <method id="method:jsxsupermix" idfk="method:jsxsupermix" inherited="1" name="jsxsupermix" source="jsx3.lang.Object"/>
  <method deprecated="1" id="method:setInstanceOf" idfk="method:setInstanceOf" inherited="1" name="setInstanceOf" source="jsx3.lang.Object"/>
</class>


text:
package nl.tno.idsa.library.actions;

import nl.tno.idsa.framework.semantics_impl.actions.Action;
import nl.tno.idsa.framework.semantics_impl.variables.GroupVariable;
import nl.tno.idsa.framework.world.GeometryType;
import nl.tno.idsa.library.models.ModelSpawn;
import nl.tno.idsa.library.roles.Ambulance;

/**
 * Created by jongsd on 7-8-15.
 */
@SuppressWarnings("unused")
public class SpawnAmbulance extends Action {
    public SpawnAmbulance() {
        super(null,
                // TODO What if there already are medics? Handle that in the model. ...
                // And make sure that all wandering medics match LocationFunction medic spawn point.
                // TODO Medic spawn points are pretty random.
                new GroupVariable(), null, GeometryType.asSet(GeometryType.POINT), ProvidesAgents.YES, AllowsInsertMoveActionBefore.NO);
        setModel(new ModelSpawn(this, Ambulance.class));
    }

    @Override
    @SuppressWarnings("unchecked") // Generic array.
    protected Class<? extends Action>[] createSemanticSuperclassArray() {
        return null;
    }
}


text:
import os, sys, re, subprocess, json

class MediaInfo :
    def __init__(self, **kwargs) :
        self.filename = kwargs.get('filename')
        self.cmd      = kwargs.get('cmd')
        self.info     = dict()

        if self.filename == None :
            self.filename = ''

        if self.cmd == None :
            for cmdpath in os.environ['PATH'].split(':') :
                if os.path.isdir(cmdpath) and 'mediainfo' in os.listdir(cmdpath) :
                    self.cmd = cmdpath + '/mediainfo'
                elif os.path.isdir(cmdpath) and 'ffprobe' in os.listdir(cmdpath) :
                    self.cmd = cmdpath + '/ffprobe'

            if self.cmd == None :
                self.cmd = ''

    def getInfo(self) :
        if not os.path.exists(self.filename) or not os.path.exists(self.cmd) :
            return None

        cmdName = os.path.basename(self.cmd)

        if cmdName == 'ffprobe' :
            self._ffmpegGetInfo()
        elif cmdName == 'mediainfo' :
            self._mediainfoGetInfo()

        return self.info

    def _ffmpegGetInfo(self) :
        cmd         = self.cmd + ' -loglevel quiet -print_format json -show_format -show_streams -show_error -count_frames -i ' + self.filename
        outputBytes = ''

        try :
            outputBytes = subprocess.check_output(cmd, shell = True)
        except subprocess.CalledProcessError as e :
            return ''

        outputText = outputBytes.decode('utf-8')
        self.info  = self._ffmpegGetInfoJson(outputText)

    def _ffmpegGetInfoJson(self, sourceString) :
        mediaInfo = dict()
        infoDict  = dict()

        try :
            infoDict = json.loads(sourceString)
        except json.JSONDecodeError as err :
            return mediaInfo

        mediaInfo['container'] = infoDict.get('format').get('format_name')
        mediaInfo['fileSize']  = infoDict.get('format').get('size')
        mediaInfo['duration']  = infoDict.get('format').get('duration')
        mediaInfo['bitrate']   = infoDict.get('format').get('bit_rate')

        videoStreamIndex = None
        audioStreamIndex = None

        for item in infoDict.get('streams') :
            codec_type = item.get('codec_type')

            if codec_type == 'video' :
                videoStreamIndex       = item.get('index')
                mediaInfo['haveVideo'] = 1
            elif codec_type == 'audio' :
                audioStreamIndex       = item.get('index')
                mediaInfo['haveAudio'] = 1

        if mediaInfo.get('haveVideo') :
            mediaInfo['videoCodec']        = infoDict.get('streams')[videoStreamIndex].get('codec_name')
            mediaInfo['videoCodecProfile'] = infoDict.get('streams')[videoStreamIndex].get('profile')
            mediaInfo['videoDuration']     = infoDict.get('streams')[videoStreamIndex].get('duration')
            mediaInfo['videoBitrate']      = infoDict.get('streams')[videoStreamIndex].get('bit_rate')
            mediaInfo['videoWidth']        = infoDict.get('streams')[videoStreamIndex].get('width')
            mediaInfo['videoHeight']       = infoDict.get('streams')[videoStreamIndex].get('height')
            mediaInfo['videoAspectRatio']  = infoDict.get('streams')[videoStreamIndex].get('display_aspect_ratio')
            mediaInfo['videoFrameRate']    = infoDict.get('streams')[videoStreamIndex].get('r_frame_rate')
            mediaInfo['videoFrameCount']   = infoDict.get('streams')[videoStreamIndex].get('nb_read_frames')

        if mediaInfo.get('haveAudio') :
            mediaInfo['audioCodec']        = infoDict.get('streams')[audioStreamIndex].get('codec_name')
            mediaInfo['audioCodecProfile'] = infoDict.get('streams')[audioStreamIndex].get('profile')
            mediaInfo['audioDuration']     = infoDict.get('streams')[audioStreamIndex].get('duration')
            mediaInfo['audioBitrate']      = infoDict.get('streams')[audioStreamIndex].get('bit_rate')
            mediaInfo['audioChannel']      = infoDict.get('streams')[audioStreamIndex].get('channels')
            mediaInfo['audioSamplingRate'] = infoDict.get('streams')[audioStreamIndex].get('sample_rate')
            mediaInfo['audioFrameCount']   = infoDict.get('streams')[audioStreamIndex].get('nb_read_frames')

        return mediaInfo

    def _mediainfoGetInfo(self) :
        prevPath    = os.getcwd()
        newPath     = os.path.abspath(os.path.dirname(self.filename))
        file        = os.path.basename(self.filename)

        version = self._getMediaInfoVersion()
        if version < 20:
            cmd         = self.cmd + ' -f ' + file
        else:
            cmd         = self.cmd + ' --Output=JSON -f ' + file
        outputBytes = ''

        try :
            os.chdir(newPath)
            try :
                outputBytes = subprocess.check_output(cmd, shell = True)
            except subprocess.CalledProcessError as e :
                return ''

            outputText = outputBytes.decode('utf-8')
        except IOError :
            os.chdir(prevPath)
            return ''
        finally:
            os.chdir(prevPath)

        if version < 20:
            self.info  = self._mediainfoGetInfoRegex(outputText)
        else:
            self.info  = self._mediainfoGetInfoJson(outputText)

    def _getMediaInfoVersion(self):
        version = 0
        cmd = self.cmd + ' --Version'

        try:
            outputBytes = subprocess.check_output(cmd, shell=True)
        except subprocess.CalledProcessError as e:
            return ''

        outputText = outputBytes.decode('utf-8')
        versionInfo  = re.search("MediaInfoLib\s*-\s*v(\d+)\.(\d+)", outputText, re.S)
        try:
            version = versionInfo.group(1)
        except Exception as e:
            print('get mediainfo version error!')

        return (int)(version)

    def _mediainfoGetInfoJson(self, sourceString):
        mediaInfo = dict()
        try :
            infoDict = json.loads(sourceString)
        except json.JSONDecodeError as err :
            return mediaInfo

        try:
            trackInfo = infoDict.get('media').get('track')
            for item in trackInfo:
                if item.get('@type') == 'General':
                    mediaInfo['container'] = item.get('Format')
                    mediaInfo['fileSize']  = item.get('FileSize')
                    mediaInfo['duration'] = item.get('Duration')
                    mediaInfo['bitrate']   = item.get('OverallBitRate')
                elif item.get('@type') == 'Video':
                    videoInfo = item
                    mediaInfo['haveVideo'] = 1
                elif item.get('@type') == 'Audio':
                    audioInfo = item
                    mediaInfo['haveAudio'] = 1

        except Exception as e:
            print(e)
            return mediaInfo

        if 'haveVideo' in mediaInfo and mediaInfo['haveVideo'] == 1:
            mediaInfo['videoCodec'] = videoInfo.get('Format')
            mediaInfo['videoCodecProfile'] = videoInfo.get('Format_Profile')
            mediaInfo['videoDuration'] = videoInfo.get('Duration')
            mediaInfo['videoBitrate'] = videoInfo.get('BitRate')
            mediaInfo['videoWidth'] = (int)(videoInfo.get('Width'))
            mediaInfo['videoHeight'] = (int)(videoInfo.get('Height'))
            mediaInfo['videoAspectRatio'] = videoInfo.get('DisplayAspectRatio')
            mediaInfo['videoFrameRate'] = videoInfo.get('FrameRate')
            mediaInfo['videoFrameCount'] = videoInfo.get('FrameCount')

        if  'haveAudio' in mediaInfo  and mediaInfo['haveAudio'] == 1:
            mediaInfo['audioCodec'] = audioInfo.get('Format')
            mediaInfo['audioCodecProfile'] = audioInfo.get('Format_AdditionalFeatures')
            mediaInfo['audioDuration'] = audioInfo.get('Duration')
            mediaInfo['audioBitrate'] = audioInfo.get('BitRate')
            mediaInfo['audioChannel'] = audioInfo.get('Channels')
            mediaInfo['audioSamplingRate'] = audioInfo.get('SamplingRate')

        return mediaInfo

    def _mediainfoGetInfoRegex(self, sourceString) :
        mediaInfo   = dict()
        general     = re.search("(^General\n.*?\n\n)", sourceString, re.S)
        if general :
            generalInfo = general.group(0)

            container   = re.search("Format\s*:\s*([\w\_\-\\\/\. ]+)\n",    generalInfo, re.S)
            fileSize    = re.search("File size\s*:\s*(\d+)\.?\d*\n",        generalInfo, re.S)
            duration    = re.search("Duration\s*:\s*(\d+)\.?\d*\n",         generalInfo, re.S)
            bitrate     = re.search("Overall bit rate\s*:\s*(\d+)\.?\d*\n", generalInfo, re.S)

            mediaInfo['container'] = container.group(1)
            mediaInfo['fileSize']  = fileSize.group(1)
            mediaInfo['duration']  = (str)((float)(duration.group(1))/1000)
            mediaInfo['bitrate']   = bitrate.group(1)

        video     = re.search("(\nVideo[\s\#\d]*\n.*?\n\n)", sourceString, re.S)
        if video :
            mediaInfo['haveVideo'] = 1
            videoInfo = video.group(0)

            videoCodec        = re.search("Codec\s*:\s*([\w\_\-\\\/\. ]+)\n",           videoInfo, re.S)
            videoCodecProfile = re.search("Codec profile\s*:\s*([\w\_\-\\\/\@\. ]+)\n", videoInfo, re.S)
            videoDuration     = re.search("Duration\s*:\s*(\d+)\.?\d*\n",               videoInfo, re.S)
            videoBitrate      = re.search("Bit rate\s*:\s*(\d+)\n",                     videoInfo, re.S)
            videoWidth        = re.search("Width\s*:\s*(\d+)\n",                        videoInfo, re.S)
            videoHeight       = re.search("Height\s*:\s*(\d+)\n",                       videoInfo, re.S)
            videoAspectRatio  = re.search("Display aspect ratio\s*:\s*([\d\.]+)\n",     videoInfo, re.S)
            videoFrameRate    = re.search("Frame rate\s*:\s*([\d\.]+)\n",               videoInfo, re.S)
            videoFrameCount   = re.search("Frame count\s*:\s*(\d+)\.?\d*\n",            videoInfo, re.S)

            if videoCodec :
                mediaInfo['videoCodec'] = videoCodec.group(1)
            if videoCodecProfile :
                mediaInfo['videoCodecProfile'] = videoCodecProfile.group(1)
            if videoDuration :
                mediaInfo['videoDuration'] = (str)((float)(videoDuration.group(1))/1000)
            if videoBitrate :
                mediaInfo['videoBitrate'] = videoBitrate.group(1)
            if videoWidth :
                mediaInfo['videoWidth'] = (int)(videoWidth.group(1))
            if videoHeight :
                mediaInfo['videoHeight'] = (int)(videoHeight.group(1))
            if videoAspectRatio :
                mediaInfo['videoAspectRatio'] = videoAspectRatio.group(1)
            if videoFrameRate :
                mediaInfo['videoFrameRate'] = videoFrameRate.group(1)
            if videoFrameCount :
                mediaInfo['videoFrameCount'] = videoFrameCount.group(1)

        audio     = re.search("(\nAudio[\s\#\d]*\n.*?\n\n)", sourceString, re.S)
        if audio :
            mediaInfo['haveAudio'] = 1
            audioInfo = audio.group(0)
            tmpAudioCodec     = re.search("Codec\s*:\s*([\w\_\-\\\/ ]+)\n",             audioInfo, re.S)
            audioCodec        = re.search("\w+", tmpAudioCodec.group(1), re.S)
            audioCodecProfile = re.search("Codec profile\s*:\s*([\w\_\-\\\/\@\. ]+)\n", audioInfo, re.S)
            if audioCodecProfile is None :
                audioCodecProfile = re.search("Format profile\s*:\s*([\w\_\-\\\/\@\. ]+)\n", audioInfo, re.S)

            audioDuration     = re.search("Duration\s*:\s*(\d+)\.?\d*\n", audioInfo, re.S)
            audioBitrate      = re.search("Bit rate\s*:\s*(\d+)\n",       audioInfo, re.S)
            audioChannel      = re.search("Channel\(s\)\s*:\s*(\d+)\n",   audioInfo, re.S)
            samplingRate      = re.search("Sampling rate\s*:\s*([\w\_\-\\\/\@\. ]+)\n", audioInfo, re.S)
            audioSamplingRate = re.search("\d+", samplingRate.group(1), re.S)

            if audioCodec :
                mediaInfo['audioCodec'] = audioCodec.group(0)
            if audioCodecProfile :
                mediaInfo['audioCodecProfile'] = audioCodecProfile.group(1)
            if audioDuration :
                mediaInfo['audioDuration'] = (str)((float)(audioDuration.group(1))/1000)
            if audioBitrate :
                mediaInfo['audioBitrate'] = audioBitrate.group(1)
            if audioChannel :
                mediaInfo['audioChannel'] = audioChannel.group(1)
            if audioSamplingRate :
                mediaInfo['audioSamplingRate'] = audioSamplingRate.group(0)

        return mediaInfo