[AS3] Head First - OOAD AS3로 변환 두번째

이전에 포스팅한 기타 검색 프로그램의 두 번째로 객체지향 원리를 살린 cohesive버전을 AS3로 변환하였다. 변환 과정에서 Java에서 제공하고 있는 HashMap의 경우는 AS3로 기본적인 기능만을 하는 HashMap class를 만들었다.

메인 document class에서 inventory. addInstrument() 메소드를 실행할 때, 마지막 파라미터 값으로 new InstrumentSpec(HashMap)을 전달하게 되는데, 이때 HashMap 클래스의 경우 Array을 이용하여 데이터를 테이블 형태로 저장하고 있기 때문에 put과 remove과정에서 하나의 Array를 참조하므로 마지막 데이터만을 저장하게 되어 검색이 제대로 되지 않는다.

이는 addInstrument 메소드를 실행하는 시점에서 참조 형태로 HashMap 데이터 Array를 전달하기 때문에 발생하는 문제다. 이를 해결하기 위해 HashMap에 있는 Array를 복제(clone)할 필요가 생겼다. 그래서 HashMap 클래스 내에 clone() 메소드를 만들어 사용되고 있는 Array를 byteArray로 변환하여 복제하였다.

이 프로그램을 변환하면서 다시 한번 느끼는 건 단순해 보이지만 단순하지 않은, 간결하고 함축적인, 사용자가 사용하기 편리한 것과 개발자의 정신분열 증상은 항상 반비례한다는 것이다. 
Java의 버전업을 통해 지원하고 있는 클래스들을 분석하는 것은 충분히 가치가 있는 일이다. 이미 입증된 알고리즘으로 제작되었기 때문에 AS3로 변환하면 충분히 사용성에서 좀더 나을 방법을 찾을 수 있을 듯싶다.

// FindInstrumentTester.as

package{
        import flash.display.Sprite;
        public class FindInstrumentTester extends Sprite{

                public function FindInstrumentTester():void{
                        var inventory:Inventory = new Inventory();
                        initializeInventory(inventory);

                        var properties:HashMap = new HashMap();
                        properties.put("builder", Builder.GIBSON);
                        properties.put("backWood", Wood.MAPLE);
                        var whatBryanLikes:InstrumentSpec = new InstrumentSpec(properties);

                        var matchingInstruments:Array = inventory.search(whatBryanLikes);
                        if(matchingInstruments.length != 0){
                                trace("Bryan, you might like these instruments:");
                                var ilen:int = matchingInstruments.length;
                                for(var i:int=0;i<ilen;i++){
                                        var instrument:Instrument = matchingInstruments[i];
                                        var spec:InstrumentSpec = instrument.getSpec();

                                        trace("We have a " + spec.getProperty("instrumentType") +
                                        " with the following properties:");

                                        var hashMap:HashMap = spec.getProperties();
                                        var jlen:int = hashMap.length;
                                        for(var j:int=0;j<jlen;j++){
                                                var propertyName:String =
                                                String(hashMap.getHashTable()[j].key);
                                                trace("    " + propertyName + ": "
                                                +spec.getProperty(propertyName));
                                        }
                                        trace("  You can have this " +
                                        spec.getProperty("instrumentType") +
                                        " for $" + instrument.getPrice() + "\n---");
                                }
                        }else{
                                trace("Sorry, Bryan, we have nothing for you.");
                        }
                }
                private function initializeInventory(inventory:Inventory):void {
                        var properties:HashMap = new HashMap();
                        properties.put("instrumentType", InstrumentType.GUITAR);
                        properties.put("builder", Builder.COLLINGS);
                        properties.put("model", "CJ");
                        properties.put("type", Type.ACOUSTIC);
                        properties.put("numStrings", 6);
                        properties.put("topWood", Wood.INDIAN_ROSEWOOD);
                        properties.put("backWood", Wood.SITKA);
                        inventory.addInstrument("11277", 3999.95,
                        new InstrumentSpec(properties.clone()));

                        properties.put("builder", Builder.MARTIN);
                        properties.put("model", "D-18");
                        properties.put("topWood", Wood.MAHOGANY);
                        properties.put("backWood", Wood.ADIRONDACK);
                        inventory.addInstrument("122784", 5495.95,
                        new InstrumentSpec(properties.clone()));

                        properties.put("builder", Builder.FENDER);
                        properties.put("model", "Stratocastor");
                        properties.put("type", Type.ELECTRIC);
                        properties.put("topWood", Wood.ALDER);
                        properties.put("backWood", Wood.ALDER);
                        inventory.addInstrument("V95693", 1499.95,
                        new InstrumentSpec(properties.clone()));
                        inventory.addInstrument("V9512", 1549.95,
                        new InstrumentSpec(properties.clone()));

                        properties.put("builder", Builder.GIBSON);
                        properties.put("model", "Les Paul");
                        properties.put("topWood", Wood.MAPLE);
                        properties.put("backWood", Wood.MAPLE);
                        inventory.addInstrument("70108276", 2295.95,
                        new InstrumentSpec(properties.clone()));

                        properties.put("model", "SG '61 Reissue");
                        properties.put("topWood", Wood.MAHOGANY);
                        properties.put("backWood", Wood.MAHOGANY);
                        inventory.addInstrument("82765501", 1890.95,
                        new InstrumentSpec(properties.clone()));

                        properties.put("instrumentType", InstrumentType.MANDOLIN);
                        properties.put("type", Type.ACOUSTIC);
                        properties.put("model", "F-5G");
                        properties.put("backWood", Wood.MAPLE);
                        properties.put("topWood", Wood.MAPLE);
                        properties.remove("numStrings");
                        inventory.addInstrument("9019920", 5495.99,
                        new InstrumentSpec(properties.clone()));

                        properties.put("instrumentType", InstrumentType.BANJO);
                        properties.put("model", "RB-3 Wreath");
                        properties.remove("topWood");
                        properties.put("numStrings", 5);
                        inventory.addInstrument("8900231", 2945.95,
                        new InstrumentSpec(properties.clone()));
                }
        }
}

//  Inventory.as

package{
        public class Inventory{
                private var inventory:Array;
                public function Inventory():void{
                        inventory = new Array();
                }
                public function addInstrument(serialNumber:String,
                price:Number,
                spec:InstrumentSpec):void{
                        var instrument:Instrument = new Instrument(serialNumber,
                        price,
                        spec);
                        inventory.push(instrument);
                }
                public function get(serialNumber:String):Instrument{
                        var len:int = inventory.length;
                        for(var i:int=0;i<len;i++){
                                if(inventory[i].getSerialNumber() == serialNumber){
                                        return inventory[i];
                                }
                        }
                        return null;
                }
                public function search(searchSpec:InstrumentSpec):Array{
                        var matchingInstruments = new Array();
                        var len:int = inventory.length;
                        for(var i:int=0;i<len;i++){
                                if(inventory[i].getSpec().matches(searchSpec)){
                                        matchingInstruments.push(inventory[i]);
                                }
                        }
                        return matchingInstruments;
                }
        }

}

// Instrument.as

package{
        public class Instrument{
                private var serialNumber:String;
                private var price:Number;
                private var spec:InstrumentSpec;
                public function Instrument(serialNumber:String,
                price:Number,
                spec:InstrumentSpec) {
                        this.serialNumber = serialNumber;
                        this.price = price;
                        this.spec = spec;
                }
                public function getSerialNumber():String {
                        return serialNumber;
                }
                public function getPrice():Number{
                        return price;
                }
                public function setPrice(newPrice:Number):void{
                        price = newPrice;
                }
                public function getSpec():InstrumentSpec{
                        return spec;
                }
        }
}

// InstrumentSpec.as

package{
        public class InstrumentSpec{
                private var properties:HashMap;
                public function InstrumentSpec(properties:HashMap=null):void{
                        if (properties == null) {
                                this.properties = new HashMap();
                        } else {
                                this.properties = new HashMap(properties);
                        }
                }
                public function getProperty(propertyName:String):*{
                        return properties.getValue(propertyName);
                }
                public function getProperties():HashMap{
                        return properties;
                }
                public function matches(otherSpec:InstrumentSpec):Boolean{
                        var otherHashMap:HashMap = otherSpec.getProperties();
                        var len:int = otherHashMap.length;

                        var hashTable:Array = otherHashMap.getHashTable();

                        for (var i:int=0; i<len; i++ ) {
                                var propertyName:String = String(hashTable[i].key);

                                if (String(properties.getValue(propertyName)) !=
                                String(otherHashMap.getValue(propertyName))) {
                                        return false;
                                }
                        }
                        return true;
                }
        }
}

// HashMap.as

package{
        import flash.utils.ByteArray;
        public class HashMap{
                private var hashTable:Array;
                public function HashMap(hm:HashMap=null):void{
                        if (hm == null) {
                                hashTable = new Array();
                        } else {
                                hashTable = hm.getHashTable();
                        }
                }
                public function put(k:*, v:*):*{
                        var len:int = length;
                        for(var i:int=0;i<len;i++){
                                if(hashTable[i].key == k){
                                        hashTable[i].key = k;
                                        hashTable[i].value = v;
                                        return v;
                                }
                        }
                        hashTable.push({key:k, value:v});
                        return v;
                }
                public function remove(k:*):Boolean{
                        var len:int = length;
                        for(var i:int=0;i<len;i++){
                                if(hashTable[i].key == k){
                                        hashTable.splice(i,1);
                                        return true;
                                }
                        }
                        return false;
                }
                public function getValue(k:*):*{
                        var len:int = length;
                        for(var i:int=0;i<len;i++){
                                if(hashTable[i].key == k){
                                        return hashTable[i].value;
                                }
                        }
                        return null;
                }
                // this function for test
                public function allTrace():void{
                        var len:int = length;
                        for(var i:int=0;i<len;i++){
                                trace(String(hashTable[i].key)+" : "+String(hashTable[i].value));
                        }
                }
                public function getHashTable():Array{
                        return hashTable;
                }
                public function setHashTable(hashTable:Array):void{
                        this.hashTable = hashTable;
                }
                public function get length():int{
                        return hashTable.length;
                }
                public function clone():HashMap{
                        var hm:HashMap = new HashMap();
                        var hashTableBA:ByteArray = new ByteArray();
                        hashTableBA.writeObject(hashTable);
                        hashTableBA.position = 0;
                        var ary:Array = hashTableBA.readObject() as Array;
                        hm.setHashTable(ary);
                        return hm;
                }
        }
}

// Builder.as

package{
        public class Builder{
                public static const FENDER = "Fender";
                public static const MARTIN = "Martin";
                public static const GIBSON = "Gibson";
                public static const COLLINGS = "Collings";
                public static const OLSON = "Olson";
                public static const RYAN = "Ryan";
                public static const PRS = "PRS";
        }
}

// InstrumentType.as

package{
        public class InstrumentType{
                public static const GUITAR = "Guitar";
                public static const BANJO = "Banjo";
                public static const DOBRO = "Dobro";
                public static const FIDDLE = "Fiddle";
                public static const BASS = "Bass";
                public static const MANDOLIN = "Mandolin";
        }
}

// Type.as

package{
        public class Type{
                public static const ACOUSTIC = "acoustic";
                public static const ELECTRIC = "Belectric";
        }
}

// Wood.as

package{
        public class Wood{
                public static const INDIAN_ROSEWOOD = "Indian Rosewood";
                public static const BRAZILIAN_ROSEWOOD = "Brazilian Rosewood";
                public static const MAHOGANY = "Mahogany";
                public static const MAPLE = "Maple";
                public static const COCOBOLO = "Cocobolo";
                public static const CEDAR = "Cedar";
                public static const ADIRONDACK = "Adirondack";
                public static const ALDER = "Alder";
                public static const SITKA = "Sitka";
        }
}