LaCiudadX

public class CifradoPerm {
 
	public static void main(String args[]){
		int m    = 6;
		int pi[] = new int[]{3, 5, 2, 1, 6, 4};
 
		String textoclaro = "12345678910abc"
 
		String textocifrado = cifra(textoclaro, m, pi);
		System.out.println(textocifrado);
 
	}
 
	static public String cifra(String textoclaro, int m, int pi[]){
		char bloques[] = textoclaro.replaceAll(" ", "").toCharArray();
		int b = (int)(Math.ceil((float)bloques.length/(float)m));
		char permuta[] = new char[b*m];
 
		for( int i = 0; i < b; i++ ){
			for( int j = 0; j < m; j++ ){
				if( m*i+pi[j]-1 < bloques.length )
					permuta[m*i+j] = bloques[m*i+pi[j]-1];
				else
					permuta[m*i+j] = ' ';
			}
		}
		return new String(permuta);
	}
}

.model small
 
.code
 
inicio:
 
; Direccion del segmento de datos en ds, es
mov ax, @data
mov ds, ax
mov es, ax
 
; Leer de izq a derecha
cld
 
; Asigna las cadenas a copiar
mov cl,20   ; Longitud
lea si,cad1 ; Origen
lea di,cad2 ; Destino
rep movsb   ; Mueve la cadena
 
; Imprime cad1
lea dx,cad1
mov ah,9h ; Funcion 9H de la interrupcion 21h para imprimir una cadena en pantalla
int 21h   ; La cadena debe estar en dx
 
; Imprime cad2
lea dx,cad2
mov ah,9h ; Funcion 9H de la interrupcion 21h para imprimir una cadena en pantalla
int 21h   ; La cadena debe estar en dx
 
; Termina el programa
mov ah,4ch ; Funcion 4CH de la int 21H para finalizar el programa con codigo de retorno
int 21h    ; El codigo es opcional y va en AL
 
.data
cad1 db 10,13,"Esta es la cadena1", "$"
cad2 db 20 dup (' '), "$"
 
.stack
 
end inicio

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Cachable {
}

import java.util.HashMap;
import java.util.Map;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import annotations.Cachable;
 
@Aspect
public class CacheAspect {
 
    final static int TIME_CACHE = 300;
    private final Map<string, CacheJoinPoint> cache = new WeakHashMap<string, CacheJoinPoint>();
 
    @Around("execution(* *(..)) && @annotation(annotations.Cachable)")
    public Object aroundProfileMethods(final ProceedingJoinPoint thisJoinPoint)
		throws Throwable {
        final String thisJoinPointName = AspectJHelper.getJoinPointName(thisJoinPoint);
        final String thisJoinPointArgs = AspectJHelper.getJointPointArgs(thisJoinPoint);
        final String objName = thisJoinPointName + "-" + thisJoinPointArgs;
        CacheJoinPoint obj = this.cache.get(objName);
        if (obj == null) {
            Object value = thisJoinPoint.proceed();
            CacheJoinPoint cjp = new CacheJoinPoint(System.currentTimeMillis(), value);
            this.cache.put(objName, cjp);
            return value;
        }else{
            if(System.currentTimeMillis() - obj.getTime() > TIME_CACHE){
                Object value = thisJoinPoint.proceed();
                CacheJoinPoint cjp = new CacheJoinPoint(System.currentTimeMillis(), value);
                this.cache.put(objName, cjp);
                return value;
            }
        }
        return obj.getValue();
    }
}

public class CacheJoinPoint {
    private Object value;
    private long time;
 
    public CacheJoinPoint(long time, Object value){
        this.time = time;
        this.value = value;
    }
 
    public long getTime() {
        return time;
    }
 
    public void setTime(long time) {
        this.time = time;
    }
 
    public Object getValue() {
        return value;
    }
 
    public void setValue(Object value) {
        this.value = value;
    }
}

import org.aspectj.lang.JoinPoint;
 
public class AspectJHelper {
 
    public static final String getJoinPointName(final JoinPoint joinPoint) {
        return joinPoint.getThis().getClass().getSimpleName() +
		"." + joinPoint.getSignature().getName();
    }
 
    public static final String getJointPointArgs(final JoinPoint joinPoint) {
        final StringBuilder buf = new StringBuilder();
        for (final Object arg : joinPoint.getArgs()) {
            buf.append(arg.getClass().getSimpleName() + "-" + arg + "+");
        }
        return buf.toString().replaceAll("\\+$", "");
    }
}

@Cachable
public Objeto getObjeto(int param) {
	...
	return value;
}

public class Persona {
    private String nombre;
    private int edad;
    private List amigos = new ArrayList();
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public int getEdad() {
        return edad;
    }
 
    public void setEdad(int edad) {
        this.edad = edad;
    }
 
    public List getAmigos() {
        return amigos;
    }
 
    public void addAmigo(String amigo) {
        amigos.add(amigo);
    }
}

import com.thoughtworks.xstream.XStream;
 
public class XStreamTest {
 
    public static void main(String[] args) {
        XStream xstream = new XStream();
        xstream.alias("persona", Persona.class);
        Persona yo = new Persona();
        yo.setNombre("Sergio Ceron");
        yo.setEdad(19);
        yo.addAmigo("Some friend ;)");
        String xml = xstream.toXML(yo);
        System.out.println(xml);
    }
 
}

  Sergio Ceron
  19
 
    Some friend ;)

  Sergio Ceron
  19
 
    Some friend ;)

public static void main(String[] args) {
        XStream xstream = new XStream();
        xstream.alias("persona", Persona.class);
 
        String xml =
                "
" +
                "   Sergio Ceron" +
                "   19" +
                "   " +
                "       Some friend ;)" +
                "   " +
                "";
        Persona yo = (Persona)xstream.fromXML(xml);
        System.out.println( "Me llamo: " + yo.getNombre() );
        System.out.println( "Tengo: " + yo.getEdad() + " años" );
        System.out.println( "Mis amigos: " );
        for( String amigo : yo.getAmigos() )
            System.out.println( amigo );
    }

<bean id="daoAuthenticationProvider"
	class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
        <property name="userDetailsService">
		<ref bean="userDetailsService" />
        </property>
        <property name="passwordEncoder">
		<ref local="passwordEncoder"/>
	</property>
    </bean>
 
    <!-- Custom User Detail Service -->
    <bean id="userDetailsService"
	class="org.security.AuthenticationJdbcDaoImpl">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
        <property name="userInfoObjectTypes">
            <list>
                <value>Usuario</value>
            </list>
        </property>
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

import org.acegisecurity.userdetails.UserDetails;
import org.acegisecurity.userdetails.UsernameNotFoundException;
import org.acegisecurity.userdetails.jdbc.JdbcDaoImpl;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.dao.DataAccessException;
 
public class AuthenticationJdbcDaoImpl extends JdbcDaoImpl {
 
    private String[] userInfoObjectTypes;
    private SessionFactory sessionFactory;
 
    @Override
    protected void initMappingSqlQueries() {
        super.setUsersByUsernameQuery("select nombre as username, password, enabled"
		+" from usuario where nombre = ?");
        super.setAuthoritiesByUsernameQuery("select usuario.nombre as username, "
		+"authorities.permission as authority from usuario, authorities, "
		+"usuario_authorities where usuario_id=usuario.id and "
		+"autorities_id=authorities.id and usuario.nombre = ?");
        super.initMappingSqlQueries();
    }
 
    @Override
    public UserDetails loadUserByUsername(String username) {
        try {
            UserDetails user = super.loadUserByUsername(username);
            Session session = sessionFactory.openSession();
            for (int i = 0; i < userInfoObjectTypes.length; i++) {
 
                Object userInfo = session.createQuery("from " + userInfoObjectTypes[i] +
			" where nombre = '" + username + "'").uniqueResult();
                if (userInfo != null) {
                    session.close();
                    return new CustomUser(user.getUsername(), user.getPassword(),
			user.isEnabled(), user.getAuthorities(), userInfo);
                }
            }
            session.close();
            return new CustomUser(user.getUsername(), user.getPassword(),
			user.isEnabled(), user.getAuthorities());
        } catch (UsernameNotFoundException ex1) {
            ex1.printStackTrace();
            throw ex1;
        } catch (DataAccessException ex2) {
            ex2.printStackTrace();
            throw ex2;
        }
    }
 
    public void setUserInfoObjectTypes(String[] userInfoObjectTypes) {
        this.userInfoObjectTypes = userInfoObjectTypes;
    }
 
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
}

import org.acegisecurity.GrantedAuthority;
import org.acegisecurity.userdetails.User;
 
public class CustomUser extends User {
 
    private Object userInfo;
 
    public CustomUser(String username, String password, boolean isEnabled,
			GrantedAuthority[] authorities, Object user) {
        super(username, password, isEnabled, true, true, true, authorities);
        this.setUserInfo(user);
    }
 
    public CustomUser(String username, String password, boolean isEnabled,
			GrantedAuthority[] arrayAuths) {
        super(username, password, isEnabled, true, true, true, arrayAuths);
    }
 
    public Object getUserInfo() {
        return userInfo;
    }
 
    public void setUserInfo(Object userInfo) {
        this.userInfo = userInfo;
    }
}

@Resource
private Dao dao;
...
public String auth_login_action(){
        try{
            authenticate( j_username.getText(), j_password.getValue().toString() );
            Authentication auth = SecurityContextHolder.getContext().getAuthentication();
            CustomUser customUser = (CustomUser)(auth.getPrincipal());
            for( GrantedAuthority ga : customUser.getAuthorities() )
                System.out.println( ga.getAuthority() );
            Object usuario =  customUser.getUserInfo();
            dao.lock(usuario);
            if( usuario instanceof Empleado ){
                empleadoMgr.setEmpleado((Empleado)usuario);
            }
            return "sucess";
        }catch(Exception e){}
        return null;
    }
...