pragma solidity ^0.4.21;

contract SensingWifi{
    uint public rewardUnit;
    uint public rewardNum;
    uint public dataCount;
    bytes32 public wifiName;
    address public requester;
    enum State {Uncreated, Created, Inactive}
    State public state;

    mapping(bytes32 => string) dataStatuses; // Either '' or 'Committed'

    modifier condition(bool _condition) {
        require(_condition);
        _;
    }

    modifier onlyRequester() {
        require(msg.sender == requester);
        _;
    }

    modifier inState(State _state) {
        require(state == _state);
        _;
    }

    event Aborted();
    event TaskInited();
    event DataCommited(bytes32 l, bytes32 w, int s);
    event TaskDone();

    // The requester initiates the task.
    // He needs to set the value of rewards for each sensing data,
    // as well as the maximum number of data he requires.
    function initTask(uint _rewardUnit, uint _rewardNum, bytes32 _wifiName)
        public
        inState(State.Uncreated)
        condition(msg.value >= _rewardUnit * _rewardNum)
        payable
    {
        requester = msg.sender;
        rewardUnit = _rewardUnit; // wei
        rewardNum = _rewardNum;
        wifiName = _wifiName;
        state = State.Created;
        emit TaskInited();
        
    }

    // Abort the Task and reclaim the ether,
    // Can only be called by the requester.
    function abort()
        public
        onlyRequester
        inState(State.Created)
    {
        require(dataCount <= rewardNum);
        state = State.Inactive;
        requester.transfer(this.balance);
        emit Aborted();
    }

    // The worker undertakes the task by obtaining and sending his sensing data,
    // such as {"Student Dorm 13", "SJTU", -51}
    function commitTask(bytes32 _location, bytes32 _wifiName, int _signalDegree)
        public
        inState(State.Created)
    {
        require(dataCount < rewardNum);
        bytes memory sensingDataCommit = bytes(dataStatuses[_location]);
        // The requester wants to get data from different location.
        require(sensingDataCommit.length == 0);
        
        // Make sure that the wifi signal sensed is exactly what requester wants.
        require(wifiName == _wifiName);
        
        // The theoretical maximum value of signal strength is -30 dBm.
        require(_signalDegree < -30);
  
        dataStatuses[_location] = "Committed";
        
        dataCount += 1;
        if(dataCount == rewardNum){
            state = State.Inactive;
            requester.transfer(this.balance);
            emit TaskDone();
        }
        msg.sender.transfer(rewardUnit);
      
       // The requster collects sensing data by 
       // listening the log info of DataCommited.
        emit DataCommited(_location, _wifiName, _signalDegree);
    }
}

pragma solidity ^0.4.11;

contract Micropayment{
    uint public value;
    uint public feePerMinute; // the fee is counted by wei
    uint public startTime;
    uint public endTime;
    address public serviceProvider;
    address public user;

    function Micropayment(uint fee) public {
        require(fee > 0);
        serviceProvider = msg.sender;
        feePerMinute = fee;
    }
    
    modifier condition(bool _condition) {
        require(_condition);
        _;
    }

    modifier onlyProvider() {
        require(msg.sender == serviceProvider);
        _;
    }

    modifier onlyUser() {
        require(msg.sender == user);
        _;
    }

    event ServiceStarted();
    event ServiceEnded();
    event ForceEnd();

    /// Force end the Micropayment (the service provider),
    /// and get paid,
    /// when user has run out his time.
    function forcePay()
        public
        onlyProvider
    {
        require(now >= endTime);
        ForceEnd();
        serviceProvider.transfer(this.balance);
    }

    /// Start service as user.
    /// Give a expected service time.
    function startService(uint eT) // minutes
        public
        condition(msg.value >= feePerMinute * eT)
        payable
    {
        ServiceStarted();
        user = msg.sender;
        startTime = now;
        endTime = now + eT * 1 minutes;
        value = msg.value;
    }

    /// End the service (the user).
    /// Pay bill to service provider according to using time.
    function endService()
        public
        onlyUser
    {
        require(now < endTime);
        uint usingTime = (now - startTime) / 60 + 1;
        uint bill = usingTime * feePerMinute;
        user.transfer(value - bill);
        serviceProvider.transfer(this.balance);
        ServiceEnded();
    }
}

pragma solidity ^0.4.11;

contract Channel {

    address public moneyProvider;
    address public worker;
    uint public startTime;
    uint public timeOut;
    mapping (bytes32 => address) signatures;

    function Channel(address to, uint t) payable {
        worker = to;
        moneyProvider = msg.sender;
        startTime = now;
        timeOut = t;
    }
    // this function can be both called by moneyProvider and worker,
    // we use sha3 as hash function in this case.
    function CloseChannel(bytes32 h, uint8 v, bytes32 r, bytes32 s, uint value){
        address signer;
        bytes32 proof;
        // get signer from signature
        signer = ecrecover(h, v, r, s);
        // signature is invalid, throw
        require (signer == moneyProvider || signer == worker);
        proof = sha3(this, value);
        // signature also needs to match the data provided
        require (proof == h);
        if (signatures[proof] == 0)
            signatures[proof] = signer;
        else if (signatures[proof] != signer){
            // channel completed, both signatures provided
            worker.transfer(value);
            selfdestruct(moneyProvider);
        }
    }
    // this function is called by moneyProvider, when worker is malicious.
    function moneyBack(){
        require (startTime + timeOut > now && msg.sender == moneyProvider);
        selfdestruct(moneyProvider);
    }
}

enum State { Created, Locked, Inactive }
// Created = 0, Locked = 1, Inactive = 2

require(myState == Created.Created);

library Library {
  struct data {
     uint val;
     bool isValue;
   }
}
contract myContract{
    using Library for Library.data;
    mapping(address => Library.data) cluster;
    function ifExist(address id) returns(bool){
        if(cluster[id].isValue) return true;
        return flase; 
    }
  	function addCluster(address id){
        if(cluster[id].isValue) throw; // duplicate key
        // add ...
      	cluster[id].isValue = true;
    }
  	//...
}

mapping(address => uint) public deposits;
if(deposits[msg.sender].length == 0){
    // deposit[msg.sender] is empty, do your thing
}