var milliStamp : String {
        let timeInterval: TimeInterval = Date().timeIntervalSince1970
        let millisecond = CLongLong(round(timeInterval*1000))
        return "\(millisecond)"
    }
    
    var revealSh(){
      REVEAL_APP_PATH=$(mdfind kMDItemCFBundleIdentifier="com.ittybittyapps.Reveal2" | head -n 1)
BUILD_SCRIPT_PATH="${REVEAL_APP_PATH}/Contents/SharedSupport/Scripts/reveal_server_build_phase.sh"
if [ "${REVEAL_APP_PATH}" -a -e "${BUILD_SCRIPT_PATH}" ]; then
    "${BUILD_SCRIPT_PATH}"
else
    echo "Reveal Server not loaded: Cannot find a compatible Reveal app."
fi
    }
    
    
    
        //生成k线图的测试数据  repeatCount是需要重复的次数
    var klineDataCount : Int = 0
    var basicTime : CLongLong = 1535662800
    func createKlineData(_ repeatCount : Int) ->  [String : Any]{
        
        
        
        if klineDataCount > repeatCount - 40 {
            basicTime += 60
            klineDataCount = 0
        }
        var dataArray = [Double]()
        for _ in 0..<4 {
            let value = Double(16000) + Double(arc4random() % 2000000) / 1666.6
            dataArray.append(value)
        }
        
        dataArray.sort{$0 < $1}
        let low = dataArray.first
        let high = dataArray.last
        var open = 0.0
        var close = 0.0
        let volume = Double(arc4random() % 100000) / 6.66
        
        let randomNum = arc4random() % 10
        
        if randomNum % 2 == 1 {
            open = dataArray[1]
            close = dataArray[2]
        }else{
            open = dataArray[2]
            close = dataArray[1]
        }
        var dataDic = [String : Any]()
        dataDic["T"] = basicTime
        dataDic["o"] = String(open)
        dataDic["h"] = String(high!)
        dataDic["l"] = String(low!)
        dataDic["c"] = String(close)
        dataDic["v"] = String(volume)
        
        
        //        var doubleDataArray = [basicTime,open,high,low,close]
        //        let stringDataArray = doubleDataArray.map{
        //            value in
        //            return String(value!)
        //        }
        klineDataCount += 1
        return dataDic
        
    }
    
    
    
        // 创建https的虚拟数据
    func createGetKLineDataByHttpStub() {
        //  transferArrayToJson()
        //  getJsonArrayString()
        weak var weakSelf : PKKLineDemoView! = self
        stub(condition: isHost(iOSPrincekinTestBaseURLHost)) {
            req in
            print(req)
            let dataDic = ["1":"2"]
            let stubData = try! JSONSerialization.data(withJSONObject: dataDic, options: .prettyPrinted)
            return OHHTTPStubsResponse(fileAtPath: OHPathForFile("data.json", type(of: weakSelf))!,statusCode: 200,headers: ["Content-Type":"application/json"])
            
        }
    }
    func getDataFromHttp(){
        weak var weakSelf : PKKLineDemoView! = self
        createGetKLineDataByHttpStub()
        var param : [String : Any] = [String : Any]()
        param["symbol"] = wSymbol   //"CZRETH"
        let urlString : String = iOSPrincekinTestBaseURL + "/kline"
        Alamofire.request(urlString, method: .get, parameters: param, encoding:  URLEncoding.default, headers: nil).responseJSON {response in
            let dataArray : [[String]]? = response.value as? [[String]]
            
            if dataArray == nil{
                return
            }
            let klineGroup = PKKLineGroup()
            klineGroup.klineArray = PKKLineGroup.klineArray(klineStringArray: dataArray!)
            weakSelf.initData(klineArray: klineGroup.klineArray)
            weakSelf.initFullVCData()
            weakSelf.socket?.socketDelegate = weakSelf
        }
    }

// HideKeyboard
// Вызовите self.hideKeyboard() в viewDidLoad
extension CalcViewController {
    func hideKeyboard()
    {
        let tap: UITapGestureRecognizer = UITapGestureRecognizer(
            target: self,
            action: #selector(CalcViewController.dismissKeyboard))
        
        tap.cancelsTouchesInView = false
        view.addGestureRecognizer(tap)
    }
    
    @objc func dismissKeyboard()
    {
        view.endEditing(true)
    }
}

#if DEBUG
print(<#T##items: Any...##Any#>)
#endif

enum Month {
    case january, february, june, july
}
let month: Month = .july

enum Semester {
    ///comment
    case fall
    
    ///comment
    case spring
    
    ///comment
    case summer
}


let semester: Semester
switch month {
case .january, .february:
    semester = .fall
case .june, .july:
    semester = .summer
}


enum Month3: Int {
case jan = 1, february, june, july

    }
Month3.jan.rawValue
Month3(rawValue: 4)
        

let coordinates = (0.0, 5.0)
let twoDimensionalPoint: TwoDimensionalPoint

switch coordinates {
case (0, 0):
  twoDimensionalPoint = .origin
case (_, 0):
  twoDimensionalPoint = .onXAxis(coordinates.0)
case (0, _):
  twoDimensionalPoint = .onYAxis(coordinates.1)
default:
  twoDimensionalPoint = .noZeroCoordinate(coordinates.0, coordinates.1)
}

let pointValue: (Double, Double)
switch twoDimensionalPoint {
case .origin:
  pointValue = (0, 0)
case let .onXAxis(x):
  pointValue = (x, 0)
case .onYAxis(let y):
  pointValue = (0, y)
case .noZeroCoordinate(let x, let y):
  pointValue = (x, y)
}

let number = Int.max
let numberDescription: String

switch number {
case 0:
    numberDescription = "Zero"
case 1...9:
    numberDescription = "Between 1 and 9"
case let negativeNumber where negativeNumber < 0:
    numberDescription = "Negative"
case _ where number > .max / 2:
    numberDescription = "Very large!"
default:
    numberDescription = "No Description"
}


let numberIsEven: Bool

switch number % 2 {
case 0:
    numberIsEven = true
default:
    numberIsEven = false
}

let animalString = "Elephant"
let isHousePet: Bool

switch animalString   {
case "Dog", "Cat", "Potbellied Hamster":
    isHousePet = true
default:
    isHousePet = false
}


let coordinates = (2, 2)
let pointCategory: String

switch coordinates{
case(0,0):
    pointCategory = "Origin"
case(let x, 0):
    pointCategory = "On the x-axis at \(x)"
case let (x,y) where y == x*x:
    pointCategory = "Along y = x ^ 2"
case (_, let y) where coordinates.0 == y:
    pointCategory = "Along y = x"
case _ where coordinates.0 == coordinates.1:
    pointCategory = "Along y = x"
default: break
}

if let remoteNotification = launchOptions?[.remoteNotification] as? [AnyHashable : Any] {
            checkForNotification(remoteNotification)
        } else {
          ifLoggedIn()
        }
        
        func checkForNotification(_ remoteNotification: [AnyHashable : Any]) {
        if let option = remoteNotification["option"] as? String {
            let story = UIStoryboard(name: "Main", bundle: nil)
            if option == "Booking" {
              let orders = story.instantiateViewController(withIdentifier: "MyOrdersVC") as! MyOrdersVC
                orders.openedBy = .notification
                createRootViewController(vc: orders)
            } else {
                guard let name = remoteNotification["name"] as? String, let taskerId = remoteNotification["tasker_id"] as? String else { return }
                let chat = story.instantiateViewController(withIdentifier: "ChatVC") as! ChatVC
                chat.taskerId = taskerId
                chat.chatingName = name
                createRootViewController(vc: chat)
            }
        }
    }

if let bundle = Bundle.main.bundleIdentifier {
    UserDefaults.standard.removePersistentDomain(forName: bundle)
}

// source: http://ios-tutorial.com/how-to-save-array-of-custom-objects-to-nsuserdefaults/
// Important, for float decode using 
self.maxValue = (aDecoder.decodeFloat(forKey: Keys.maxValue.rawValue))
// not by (aDecoder.decodeObject(forKey: Keys.maxValue.rawValue) as? Float)!

class Parameter: NSObject, NSCoding {
    
//    var itemID: Int?
//    var itemName: String?
    var name = ""
    var minValue:Float = 0.0
    var maxValue:Float = 1.0
    var currentValue:Float = 0.0
    
    private enum Keys : String {
        case name = "name",
        minValue = "minValue",
        maxValue = "maxValue",
        currentValue = "currentValue"
    }
    
    init(name: String, minValue: Float, maxValue: Float, currentValue: Float)
    {
        self.name = name
        self.minValue = minValue
        self.maxValue = maxValue
        self.currentValue = currentValue
    }
    
    func encode(with aCoder: NSCoder)
    {
        aCoder.encode(self.name, forKey: Keys.name.rawValue)
        aCoder.encode(self.minValue, forKey: Keys.minValue.rawValue)
        aCoder.encode(self.maxValue, forKey: Keys.maxValue.rawValue)
        aCoder.encode(self.currentValue, forKey: Keys.currentValue.rawValue)
    }
    
    required init?(coder aDecoder: NSCoder)
    {
        self.name = (aDecoder.decodeObject(forKey: Keys.name.rawValue) as? String)!
        self.minValue = (aDecoder.decodeFloat(forKey: Keys.minValue.rawValue))
        self.maxValue = (aDecoder.decodeFloat(forKey: Keys.maxValue.rawValue))
        self.currentValue = (aDecoder.decodeFloat(forKey: Keys.currentValue.rawValue))
        
    }
    
}

	// initiating
	 enum Keys : String {
        case name = "name",
        minValue = "minValue",
        maxValue = "maxValue",
        currentValue = "currentValue"
    }
	
// declaring
var key : Keys = .name
aCoder.encode(self.name, forKey: Keys.name.rawValue)

// enums are declared on the top of file just below import
// enums and case are Capital letter 

Float(round(1000*a)/1000)