import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * A list of all <em>registered</em> architectures.
 */
public static Collection<Class<? extends Architecture>> architectures() {
    if (API.machine != null)
        return API.machine.architectures();
    return Collections.emptyList();
}
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
@Override
public Architecture architecture() {
	// TODO Auto-generated method stub
	return null;
}
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * Register an architecture that can be used to create new machines.
 * <p/>
 * Registering an architecture will make it possible to configure CPUs to
 * run that architecture. This allows providing architectures without
 * implementing a custom CPU item.
 *
 * @param architecture the architecture to register.
 */
public static void add(Class<? extends Architecture> architecture) {
    if (API.machine != null)
        API.machine.add(architecture);
}
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * Get the name of the specified architecture.
 *
 * @param architecture the architecture to get the name for.
 * @return the name of the specified architecture.
 */
public static String getArchitectureName(Class<? extends Architecture> architecture) {
    if (API.machine != null)
        return API.machine.getArchitectureName(architecture);
    return null;
}
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * Get a list of all architectures supported by this processor.
 */
java.util.Collection<Class<? extends Architecture>> allArchitectures();
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * Set the architecture to use for the specified processor.
 *
 * @param stack        the processor to set the architecture for.
 * @param architecture the architecture to use on the processor.
 */
void setArchitecture(ItemStack stack, Class<? extends Architecture> architecture);
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * The architecture of this CPU.
 * <p/>
 * This usually controls which architecture is created for a machine the
 * CPU is installed in (this is true for all computers built into OC, such
 * as computer cases, server racks and robots, it my not be true for third-
 * party computers).
 *
 * @param stack the stack representing the CPU to get the architecture for.
 * @return the type of this CPU's architecture.
 */
Class<? extends Architecture> architecture(ItemStack stack);
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * Register an architecture that can be used to create new machines.
 * <p/>
 * Note that although registration is optional, it is strongly recommended
 * to allow {@link #architectures()} to be useful.
 *
 * @param architecture the architecture to register.
 * @throws IllegalArgumentException if the specified architecture is invalid.
 */
void add(Class<? extends Architecture> architecture);
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * A list of all <em>registered</em> architectures.
 * <p/>
 * Note that registration is optional, although automatic when calling
 * {@link #create(li.cil.oc.api.machine.MachineHost)} with a not yet
 * registered architecture. What this means is that unless a mod providing
 * a custom architecture also registers it, you may not see it in this list
 * until it also created a new machine using that architecture.
 */
Collection<Class<? extends Architecture>> architectures();
 

import li.cil.oc.api.machine.Architecture; //导入依赖的package包/类
/**
 * Get the name of the specified architecture.
 *
 * @param architecture the architecture to get the name for.
 * @return the name of the specified architecture.
 */
String getArchitectureName(Class<? extends Architecture> architecture);