text:
namespace Kvasir {
//High Speed MultiMedia Card Interface 1
    namespace Hsmci1Cr{    ///<Control Register
        using Addr = Register::Address<0xfffd0000,0xffffff70,0x00000000,unsigned>;
        ///Multi-Media Interface Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> mcien{};
        ///Multi-Media Interface Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> mcidis{};
        ///Power Save Mode Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> pwsen{};
        ///Power Save Mode Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> pwsdis{};
        ///Software Reset
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> swrst{};
    }
    namespace Hsmci1Mr{    ///<Mode Register
        using Addr = Register::Address<0xfffd0004,0x00008000,0x00000000,unsigned>;
        ///Clock Divider
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> clkdiv{};
        ///Power Saving Divider
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,8),Register::ReadWriteAccess,unsigned> pwsdiv{};
        ///
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(11,11),Register::ReadWriteAccess,unsigned> rdproof{};
        ///
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::ReadWriteAccess,unsigned> wrproof{};
        ///Force Byte Transfer
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,13),Register::ReadWriteAccess,unsigned> fbyte{};
        ///Padding Value
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,14),Register::ReadWriteAccess,unsigned> padv{};
        ///Data Block Length
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> blklen{};
    }
    namespace Hsmci1Dtor{    ///<Data Timeout Register
        using Addr = Register::Address<0xfffd0008,0xffffff80,0x00000000,unsigned>;
        ///Data Timeout Cycle Number
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,0),Register::ReadWriteAccess,unsigned> dtocyc{};
        ///Data Timeout Multiplier
        enum class DtomulVal {
            v1=0x00000000,     ///<DTOCYC
            v16=0x00000001,     ///<DTOCYC x 16
            v128=0x00000002,     ///<DTOCYC x 128
            v256=0x00000003,     ///<DTOCYC x 256
            v1024=0x00000004,     ///<DTOCYC x 1024
            v4096=0x00000005,     ///<DTOCYC x 4096
            v65536=0x00000006,     ///<DTOCYC x 65536
            v1048576=0x00000007,     ///<DTOCYC x 1048576
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,4),Register::ReadWriteAccess,DtomulVal> dtomul{};
        namespace DtomulValC{
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v1> v1{};
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v16> v16{};
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v128> v128{};
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v256> v256{};
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v1024> v1024{};
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v4096> v4096{};
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v65536> v65536{};
            constexpr Register::FieldValue<decltype(dtomul)::Type,DtomulVal::v1048576> v1048576{};
        }
    }
    namespace Hsmci1Sdcr{    ///<SD/SDIO Card Register
        using Addr = Register::Address<0xfffd000c,0xffffff3c,0x00000000,unsigned>;
        ///SDCard/SDIO Slot
        enum class SdcselVal {
            slota=0x00000000,     ///<Slot A is selected.
            slotb=0x00000001,     ///<-
            slotc=0x00000002,     ///<-
            slotd=0x00000003,     ///<-
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,SdcselVal> sdcsel{};
        namespace SdcselValC{
            constexpr Register::FieldValue<decltype(sdcsel)::Type,SdcselVal::slota> slota{};
            constexpr Register::FieldValue<decltype(sdcsel)::Type,SdcselVal::slotb> slotb{};
            constexpr Register::FieldValue<decltype(sdcsel)::Type,SdcselVal::slotc> slotc{};
            constexpr Register::FieldValue<decltype(sdcsel)::Type,SdcselVal::slotd> slotd{};
        }
        ///SDCard/SDIO Bus Width
        enum class SdcbusVal {
            v1=0x00000000,     ///<1 bit
            v4=0x00000001,     ///<4 bit
            v8=0x00000002,     ///<8 bit
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,6),Register::ReadWriteAccess,SdcbusVal> sdcbus{};
        namespace SdcbusValC{
            constexpr Register::FieldValue<decltype(sdcbus)::Type,SdcbusVal::v1> v1{};
            constexpr Register::FieldValue<decltype(sdcbus)::Type,SdcbusVal::v4> v4{};
            constexpr Register::FieldValue<decltype(sdcbus)::Type,SdcbusVal::v8> v8{};
        }
    }
    namespace Hsmci1Argr{    ///<Argument Register
        using Addr = Register::Address<0xfffd0010,0x00000000,0x00000000,unsigned>;
        ///Command Argument
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::ReadWriteAccess,unsigned> arg{};
    }
    namespace Hsmci1Cmdr{    ///<Command Register
        using Addr = Register::Address<0xfffd0014,0xf0c0e000,0x00000000,unsigned>;
        ///Command Number
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,0),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cmdnb{};
        ///Response Type
        enum class RsptypVal {
            noresp=0x00000000,     ///<No response.
            v48Bit=0x00000001,     ///<48-bit response.
            v136Bit=0x00000002,     ///<136-bit response.
            r1b=0x00000003,     ///<R1b response type
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,6),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,RsptypVal> rsptyp{};
        namespace RsptypValC{
            constexpr Register::FieldValue<decltype(rsptyp)::Type,RsptypVal::noresp> noresp{};
            constexpr Register::FieldValue<decltype(rsptyp)::Type,RsptypVal::v48Bit> v48Bit{};
            constexpr Register::FieldValue<decltype(rsptyp)::Type,RsptypVal::v136Bit> v136Bit{};
            constexpr Register::FieldValue<decltype(rsptyp)::Type,RsptypVal::r1b> r1b{};
        }
        ///Special Command
        enum class SpcmdVal {
            std=0x00000000,     ///<Not a special CMD.
            init=0x00000001,     ///<Initialization CMD:74 clock cycles for initialization sequence.
            sync=0x00000002,     ///<Synchronized CMD:Wait for the end of the current data block transfer before sending the pending command.
            ceAta=0x00000003,     ///<CE-ATA Completion Signal disable Command.The host cancels the ability for the device to return a command completion signal on the command line.
            itCmd=0x00000004,     ///<Interrupt command:Corresponds to the Interrupt Mode (CMD40).
            itResp=0x00000005,     ///<Interrupt response:Corresponds to the Interrupt Mode (CMD40).
            bor=0x00000006,     ///<Boot Operation Request.Start a boot operation mode, the host processor can read boot data from the MMC device directly.
            ebo=0x00000007,     ///<End Boot Operation.This command allows the host processor to terminate the boot operation mode.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,8),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,SpcmdVal> spcmd{};
        namespace SpcmdValC{
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::std> std{};
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::init> init{};
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::sync> sync{};
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::ceAta> ceAta{};
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::itCmd> itCmd{};
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::itResp> itResp{};
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::bor> bor{};
            constexpr Register::FieldValue<decltype(spcmd)::Type,SpcmdVal::ebo> ebo{};
        }
        ///Open Drain Command
        enum class OpdcmdVal {
            pushpull=0x00000000,     ///<Push pull command.
            opendrain=0x00000001,     ///<Open drain command.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(11,11),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,OpdcmdVal> opdcmd{};
        namespace OpdcmdValC{
            constexpr Register::FieldValue<decltype(opdcmd)::Type,OpdcmdVal::pushpull> pushpull{};
            constexpr Register::FieldValue<decltype(opdcmd)::Type,OpdcmdVal::opendrain> opendrain{};
        }
        ///Max Latency for Command to Response
        enum class MaxlatVal {
            v5=0x00000000,     ///<5-cycle max latency.
            v64=0x00000001,     ///<64-cycle max latency.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,MaxlatVal> maxlat{};
        namespace MaxlatValC{
            constexpr Register::FieldValue<decltype(maxlat)::Type,MaxlatVal::v5> v5{};
            constexpr Register::FieldValue<decltype(maxlat)::Type,MaxlatVal::v64> v64{};
        }
        ///Transfer Command
        enum class TrcmdVal {
            noData=0x00000000,     ///<No data transfer
            startData=0x00000001,     ///<Start data transfer
            stopData=0x00000002,     ///<Stop data transfer
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,16),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TrcmdVal> trcmd{};
        namespace TrcmdValC{
            constexpr Register::FieldValue<decltype(trcmd)::Type,TrcmdVal::noData> noData{};
            constexpr Register::FieldValue<decltype(trcmd)::Type,TrcmdVal::startData> startData{};
            constexpr Register::FieldValue<decltype(trcmd)::Type,TrcmdVal::stopData> stopData{};
        }
        ///Transfer Direction
        enum class TrdirVal {
            write=0x00000000,     ///<Write.
            read=0x00000001,     ///<Read.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TrdirVal> trdir{};
        namespace TrdirValC{
            constexpr Register::FieldValue<decltype(trdir)::Type,TrdirVal::write> write{};
            constexpr Register::FieldValue<decltype(trdir)::Type,TrdirVal::read> read{};
        }
        ///Transfer Type
        enum class TrtypVal {
            single=0x00000000,     ///<MMC/SDCard Single Block
            multiple=0x00000001,     ///<MMC/SDCard Multiple Block
            stream=0x00000002,     ///<MMC Stream
            byte=0x00000004,     ///<SDIO Byte
            block=0x00000005,     ///<SDIO Block
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,19),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TrtypVal> trtyp{};
        namespace TrtypValC{
            constexpr Register::FieldValue<decltype(trtyp)::Type,TrtypVal::single> single{};
            constexpr Register::FieldValue<decltype(trtyp)::Type,TrtypVal::multiple> multiple{};
            constexpr Register::FieldValue<decltype(trtyp)::Type,TrtypVal::stream> stream{};
            constexpr Register::FieldValue<decltype(trtyp)::Type,TrtypVal::byte> byte{};
            constexpr Register::FieldValue<decltype(trtyp)::Type,TrtypVal::block> block{};
        }
        ///SDIO Special Command
        enum class IospcmdVal {
            std=0x00000000,     ///<Not an SDIO Special Command
            suspend=0x00000001,     ///<SDIO Suspend Command
            resume=0x00000002,     ///<SDIO Resume Command
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(25,24),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,IospcmdVal> iospcmd{};
        namespace IospcmdValC{
            constexpr Register::FieldValue<decltype(iospcmd)::Type,IospcmdVal::std> std{};
            constexpr Register::FieldValue<decltype(iospcmd)::Type,IospcmdVal::suspend> suspend{};
            constexpr Register::FieldValue<decltype(iospcmd)::Type,IospcmdVal::resume> resume{};
        }
        ///ATA with Command Completion Signal
        enum class AtacsVal {
            normal=0x00000000,     ///<Normal operation mode.
            completion=0x00000001,     ///<This bit indicates that a completion signal is expected within a programmed amount of time (HSMCI_CSTOR).
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(26,26),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,AtacsVal> atacs{};
        namespace AtacsValC{
            constexpr Register::FieldValue<decltype(atacs)::Type,AtacsVal::normal> normal{};
            constexpr Register::FieldValue<decltype(atacs)::Type,AtacsVal::completion> completion{};
        }
        ///Boot Operation Acknowledge.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(27,27),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> bootAck{};
    }
    namespace Hsmci1Blkr{    ///<Block Register
        using Addr = Register::Address<0xfffd0018,0x00000000,0x00000000,unsigned>;
        ///MMC/SDIO Block Count - SDIO Byte Count
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> bcnt{};
        ///Data Block Length
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> blklen{};
    }
    namespace Hsmci1Cstor{    ///<Completion Signal Timeout Register
        using Addr = Register::Address<0xfffd001c,0xffffff80,0x00000000,unsigned>;
        ///Completion Signal Timeout Cycle Number
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,0),Register::ReadWriteAccess,unsigned> cstocyc{};
        ///Completion Signal Timeout Multiplier
        enum class CstomulVal {
            v1=0x00000000,     ///<CSTOCYC x 1
            v16=0x00000001,     ///<CSTOCYC x 16
            v128=0x00000002,     ///<CSTOCYC x 128
            v256=0x00000003,     ///<CSTOCYC x 256
            v1024=0x00000004,     ///<CSTOCYC x 1024
            v4096=0x00000005,     ///<CSTOCYC x 4096
            v65536=0x00000006,     ///<CSTOCYC x 65536
            v1048576=0x00000007,     ///<CSTOCYC x 1048576
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,4),Register::ReadWriteAccess,CstomulVal> cstomul{};
        namespace CstomulValC{
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v1> v1{};
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v16> v16{};
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v128> v128{};
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v256> v256{};
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v1024> v1024{};
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v4096> v4096{};
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v65536> v65536{};
            constexpr Register::FieldValue<decltype(cstomul)::Type,CstomulVal::v1048576> v1048576{};
        }
    }
    namespace Hsmci1Rdr{    ///<Receive Data Register
        using Addr = Register::Address<0xfffd0030,0x00000000,0x00000000,unsigned>;
        ///Data to Read
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> data{};
    }
    namespace Hsmci1Tdr{    ///<Transmit Data Register
        using Addr = Register::Address<0xfffd0034,0x00000000,0x00000000,unsigned>;
        ///Data to Write
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> data{};
    }
    namespace Hsmci1Sr{    ///<Status Register
        using Addr = Register::Address<0xfffd0040,0x0000cec0,0x00000000,unsigned>;
        ///Command Ready
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cmdrdy{};
        ///Receiver Ready
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rxrdy{};
        ///Transmit Ready
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> txrdy{};
        ///Data Block Ended
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blke{};
        ///Data Transfer in Progress
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtip{};
        ///HSMCI Not Busy
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> notbusy{};
        ///
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> mciSdioirqa{};
        ///SDIO Read Wait Operation Status
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> sdiowait{};
        ///CE-ATA Completion Signal Received
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,13),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> csrcv{};
        ///Response Index Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rinde{};
        ///Response Direction Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,17),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rdire{};
        ///Response CRC Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rcrce{};
        ///Response End Bit Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rende{};
        ///Response Time-out Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rtoe{};
        ///Data CRC Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dcrce{};
        ///Data Time-out Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtoe{};
        ///Completion Signal Time-out Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cstoe{};
        ///DMA Block Overrun Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,24),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blkovre{};
        ///DMA Transfer done
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(25,25),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dmadone{};
        ///FIFO empty flag
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(26,26),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> fifoempty{};
        ///Transfer Done flag
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(27,27),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> xfrdone{};
        ///Boot Operation Acknowledge Received
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,28),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcv{};
        ///Boot Operation Acknowledge Error
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(29,29),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcve{};
        ///Overrun
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ovre{};
        ///Underrun
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> unre{};
    }
    namespace Hsmci1Ier{    ///<Interrupt Enable Register
        using Addr = Register::Address<0xfffd0044,0x0000cec0,0x00000000,unsigned>;
        ///Command Ready Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cmdrdy{};
        ///Receiver Ready Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rxrdy{};
        ///Transmit Ready Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> txrdy{};
        ///Data Block Ended Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blke{};
        ///Data Transfer in Progress Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtip{};
        ///Data Not Busy Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> notbusy{};
        ///
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> mciSdioirqa{};
        ///SDIO Read Wait Operation Status Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> sdiowait{};
        ///Completion Signal Received Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,13),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> csrcv{};
        ///Response Index Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rinde{};
        ///Response Direction Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,17),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rdire{};
        ///Response CRC Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rcrce{};
        ///Response End Bit Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rende{};
        ///Response Time-out Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rtoe{};
        ///Data CRC Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dcrce{};
        ///Data Time-out Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtoe{};
        ///Completion Signal Timeout Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cstoe{};
        ///DMA Block Overrun Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,24),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blkovre{};
        ///DMA Transfer completed Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(25,25),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dmadone{};
        ///FIFO empty Interrupt enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(26,26),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> fifoempty{};
        ///Transfer Done Interrupt enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(27,27),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> xfrdone{};
        ///Boot Acknowledge Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,28),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcv{};
        ///Boot Acknowledge Error Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(29,29),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcve{};
        ///Overrun Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ovre{};
        ///Underrun Interrupt Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> unre{};
    }
    namespace Hsmci1Idr{    ///<Interrupt Disable Register
        using Addr = Register::Address<0xfffd0048,0x0000cec0,0x00000000,unsigned>;
        ///Command Ready Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cmdrdy{};
        ///Receiver Ready Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rxrdy{};
        ///Transmit Ready Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> txrdy{};
        ///Data Block Ended Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blke{};
        ///Data Transfer in Progress Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtip{};
        ///Data Not Busy Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> notbusy{};
        ///
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> mciSdioirqa{};
        ///SDIO Read Wait Operation Status Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> sdiowait{};
        ///Completion Signal received interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,13),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> csrcv{};
        ///Response Index Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rinde{};
        ///Response Direction Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,17),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rdire{};
        ///Response CRC Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rcrce{};
        ///Response End Bit Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rende{};
        ///Response Time-out Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rtoe{};
        ///Data CRC Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dcrce{};
        ///Data Time-out Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtoe{};
        ///Completion Signal Time out Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cstoe{};
        ///DMA Block Overrun Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,24),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blkovre{};
        ///DMA Transfer completed Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(25,25),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dmadone{};
        ///FIFO empty Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(26,26),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> fifoempty{};
        ///Transfer Done Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(27,27),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> xfrdone{};
        ///Boot Acknowledge Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,28),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcv{};
        ///Boot Acknowledge Error Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(29,29),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcve{};
        ///Overrun Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ovre{};
        ///Underrun Interrupt Disable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> unre{};
    }
    namespace Hsmci1Imr{    ///<Interrupt Mask Register
        using Addr = Register::Address<0xfffd004c,0x0000cec0,0x00000000,unsigned>;
        ///Command Ready Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cmdrdy{};
        ///Receiver Ready Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rxrdy{};
        ///Transmit Ready Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> txrdy{};
        ///Data Block Ended Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blke{};
        ///Data Transfer in Progress Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtip{};
        ///Data Not Busy Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> notbusy{};
        ///
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> mciSdioirqa{};
        ///SDIO Read Wait Operation Status Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> sdiowait{};
        ///Completion Signal Received Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,13),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> csrcv{};
        ///Response Index Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rinde{};
        ///Response Direction Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,17),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rdire{};
        ///Response CRC Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rcrce{};
        ///Response End Bit Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rende{};
        ///Response Time-out Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rtoe{};
        ///Data CRC Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dcrce{};
        ///Data Time-out Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dtoe{};
        ///Completion Signal Time-out Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cstoe{};
        ///DMA Block Overrun Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,24),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> blkovre{};
        ///DMA Transfer Completed Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(25,25),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dmadone{};
        ///FIFO Empty Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(26,26),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> fifoempty{};
        ///Transfer Done Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(27,27),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> xfrdone{};
        ///Boot Operation Acknowledge Received Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,28),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcv{};
        ///Boot Operation Acknowledge Error Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(29,29),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ackrcve{};
        ///Overrun Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ovre{};
        ///Underrun Interrupt Mask
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> unre{};
    }
    namespace Hsmci1Dma{    ///<DMA Configuration Register
        using Addr = Register::Address<0xfffd0050,0xffffeecc,0x00000000,unsigned>;
        ///DMA Write Buffer Offset
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,unsigned> offset{};
        ///DMA Channel Read and Write Chunk Size
        enum class ChksizeVal {
            v1=0x00000000,     ///<1 data available
            v4=0x00000001,     ///<4 data available
            v8=0x00000002,     ///<8 data available
            v16=0x00000003,     ///<16 data available
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,4),Register::ReadWriteAccess,ChksizeVal> chksize{};
        namespace ChksizeValC{
            constexpr Register::FieldValue<decltype(chksize)::Type,ChksizeVal::v1> v1{};
            constexpr Register::FieldValue<decltype(chksize)::Type,ChksizeVal::v4> v4{};
            constexpr Register::FieldValue<decltype(chksize)::Type,ChksizeVal::v8> v8{};
            constexpr Register::FieldValue<decltype(chksize)::Type,ChksizeVal::v16> v16{};
        }
        ///DMA Hardware Handshaking Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::ReadWriteAccess,unsigned> dmaen{};
        ///Read Optimization with padding
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::ReadWriteAccess,unsigned> ropt{};
    }
    namespace Hsmci1Cfg{    ///<Configuration Register
        using Addr = Register::Address<0xfffd0054,0xffffeeee,0x00000000,unsigned>;
        ///HSMCI Internal FIFO control mode
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> fifomode{};
        ///Flow Error flag reset control mode
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,unsigned> ferrctrl{};
        ///High Speed Mode
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::ReadWriteAccess,unsigned> hsmode{};
        ///Synchronize on the last block
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::ReadWriteAccess,unsigned> lsync{};
    }
    namespace Hsmci1Wpmr{    ///<Write Protection Mode Register
        using Addr = Register::Address<0xfffd00e4,0x000000fe,0x00000000,unsigned>;
        ///Write Protection Enable
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> wpEn{};
        ///Write Protection Key password
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,8),Register::ReadWriteAccess,unsigned> wpKey{};
    }
    namespace Hsmci1Wpsr{    ///<Write Protection Status Register
        using Addr = Register::Address<0xfffd00e8,0xff0000f0,0x00000000,unsigned>;
        ///Write Protection Violation Status
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> wpVs{};
        ///Write Protection Violation SouRCe
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,8),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> wpVsrc{};
    }
    namespace Hsmci1Rspr0{    ///<Response Register
        using Addr = Register::Address<0xfffd0020,0x00000000,0x00000000,unsigned>;
        ///Response
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rsp{};
    }
    namespace Hsmci1Rspr1{    ///<Response Register
        using Addr = Register::Address<0xfffd0024,0x00000000,0x00000000,unsigned>;
        ///Response
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rsp{};
    }
    namespace Hsmci1Rspr2{    ///<Response Register
        using Addr = Register::Address<0xfffd0028,0x00000000,0x00000000,unsigned>;
        ///Response
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rsp{};
    }
    namespace Hsmci1Rspr3{    ///<Response Register
        using Addr = Register::Address<0xfffd002c,0x00000000,0x00000000,unsigned>;
        ///Response
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rsp{};
    }
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>Uses of Class org.apache.hadoop.hbase.client.Action (HBase 0.98.6-hadoop2 API)</title>
<meta name="date" content="2014-09-03">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Uses of Class
org.apache.hadoop.hbase.client.Action

Packages that use Action

Package
Description

org.apache.hadoop.hbase.client

Provides HBase Client

org.apache.hadoop.hbase.protobuf

Holds classes generated from protobuf
src/main/protobuf definition files.

Uses of Action in org.apache.hadoop.hbase.client

Fields in org.apache.hadoop.hbase.client with type parameters of type Action

Modifier and Type
Field and Description

Map<byte[],List<Action<R>>>
MultiAction.actions

Methods in org.apache.hadoop.hbase.client that return types with arguments of type Action

Modifier and Type
Method and Description

List<Action<R>>
MultiAction.allActions()

Methods in org.apache.hadoop.hbase.client with parameters of type Action

Modifier and Type
Method and Description

void
MultiAction.add(byte[] regionName,
   Action<R> a)

Add an Action to this container based on it's regionName.

Uses of Action in org.apache.hadoop.hbase.protobuf

Method parameters in org.apache.hadoop.hbase.protobuf with type arguments of type Action

Modifier and Type
Method and Description

static <R> ClientProtos.RegionAction.Builder
RequestConverter.buildNoDataRegionAction(byte[] regionName,
                       List<Action<R>> actions,
                       List<CellScannable> cells,
                       ClientProtos.RegionAction.Builder regionActionBuilder,
                       ClientProtos.Action.Builder actionBuilder,
                       ClientProtos.MutationProto.Builder mutationBuilder)

Create a protocol buffer multirequest with NO data for a list of actions (data is carried
 otherwise than via protobuf).

static <R> ClientProtos.RegionAction.Builder
RequestConverter.buildRegionAction(byte[] regionName,
                 List<Action<R>> actions,
                 ClientProtos.RegionAction.Builder regionActionBuilder,
                 ClientProtos.Action.Builder actionBuilder,
                 ClientProtos.MutationProto.Builder mutationBuilder)

Create a protocol buffer multi request for a list of actions.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Copyright © 2014 The Apache Software Foundation. All rights reserved.

redpajama_set_name: RedPajamaGithub


text:
package org.keviny.gallery.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/search")
public class SearchController {

}


text:
using BlenderFileReader;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace HTMLRendererDriver
{
    ///
    /// An object that writes a file to a handy HTML file.
    ///
    class HtmlWriter
    {
        private string path;
        private string friendly;

        private int tabDepth = 0;
        private BlenderFile parsedFile;
        private string tabs { get { string s = ""; for(int i = 0; i < tabDepth; i++) s += "    "; return s; } }

        private Stack<string> breadcrumbs = new Stack<string>();

        ///
        /// Creates a new HtmlWriter.
        ///
        /// <param name="path">Output path.</param>
        /// <param name="friendlyFileName">Input file's friendly name ("cow.blend").</param>
        public HtmlWriter(BlenderFile parsedFile, string path, string friendlyFileName)
        {
            this.path = path;
            friendly = friendlyFileName;
            this.parsedFile = parsedFile;
        }

        ///
        /// Writes information to HTML.
        ///
        /// <param name="structures">List of populated structures.</param>
        public void WriteBlendFileToHtml()
        {
            writeCSS();
            using(StreamWriter writer = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write)))
            {
                writer.WriteLine("<!DOCTYPE html>");
                writeStartTag(writer, "html", "lang=\"en\"");
                writeHtmlHead(writer); //  ...
                writeBody(writer); //  ...
                writeEndTag(writer); //
            }
        }

        private void writeBody(StreamWriter writer)
        {
            writeStartTag(writer, "body");
            writeStartTag(writer, "div", "id=\"container\"");
            writeBodyHead(writer);
            writeBodyContent(writer);
            writeEndTag(writer); //

            writeEndTag(writer); //
        }

        private void writeBodyContent(StreamWriter writer)
        {
            foreach(PopulatedStructure[] block in parsedFile.Structures)
            {
                int index = 0;
                bool outer_odd = true;
                writeStartTag(writer, "div", "class=\"structure " + block[0].TypeName + (block.Length > 1 ? " list" : "") + "\"");
                writeTable(writer, new[] { "structure_head" },
                    new[] { "Structure Type:", "Structure Size:", "Number of Fields:", "File Block Address:" }, "0x" + block[0].ContainingBlock.OldMemoryAddress.ToString("X" + (parsedFile.PointerSize * 2)),
                    false, new[] { block[0].TypeName + (block.Length > 1 ? "[" + block.Length + "]" : ""), block[0].Size.ToString(), block[0].NumFields.ToString(), "0x" + block[0].ContainingBlock.OldMemoryAddress.ToString("X" + (parsedFile.PointerSize * 2)) });
                if(block.Length > 1)
                {
                    writeStartTag(writer, "table", "class=\"structure_body\"");
                    writeTableHead(writer, new[] { "Index", "Structure" });
                }
                foreach(PopulatedStructure s in block)
                {
                    if(block.Length > 1)
                    {
                        writeStartTag(writer, "tr", "class=\"index " + (outer_odd ? "odd" : "even") + "\"");
                        outer_odd = !outer_odd;
                        writeStartTag(writer, "td", "class=\"first\"");
                        writer.Write(index++);
                        writeEndTag(writer); //
                        writeStartTag(writer, "td");
                    }
                    bool odd = true;
                    int fieldNumber = 0;

                    writeStartTag(writer, "table", "class=\"structure_body\"");
                    writeTableHead(writer, new[] { "Field No.", "Identifier", "Parent Object Type", "Field Type", "Field Size", "Field Value" });
                    foreach(IField field in s)
                    {
                        writeField(writer, field, odd, fieldNumber++);
                        odd = !odd;
                    }
                    writeEndTag(writer); //

                    if(block.Length > 1)
                    {
                        writeEndTag(writer); //
                        writeEndTag(writer); //

                    }
                }
                if(block.Length > 1)
                    writeEndTag(writer); //

                writeEndTag(writer); //

            }
            writeRawDataInfo(writer);
        }

        private void writeRawDataInfo(StreamWriter writer)
        {
            writeStartTag(writer, "div", "id=\"raw_blocks\"");
            string[][] rows = new string[parsedFile.RawBlockMessages.Count][];
            for(int i = 0; i < parsedFile.RawBlockMessages.Count; i++)
                rows[i] = parsedFile.RawBlockMessages[i].Split(' ');
            for(int i = 0; i < rows.Length; i++)
                rows[i][1] = "0x" + rows[i][1] + "";
            writeTable(writer, new[] { "Raw Data Blocks:" });
            writeTable(writer, null, new[] { "Block number:", "Block Address:", "Block code:", "Block index:", "Bytes expected:", "Bytes given:" }, "raw_blocks_body", true, rows);
            writeEndTag(writer);
        }

        private void writeField(StreamWriter writer, IField field, bool odd, int fieldNumber)
        {
            string fieldVal = field.ToString();
            if(field.IsPointer)
            {
                if(field.IsArray)
                {
                    for(int i = 0; i < fieldVal.Length; i++)
                        if(fieldVal[i] == '0') // we can assume this is the start of a pointer, so the next few chars are valid
                        {
                            int j = 0;
                            do
                            {
                                j++;
                            } while(fieldVal[i + j] != ',' && fieldVal[i + j] != ' ');
                            if(fieldVal.Substring(i, j) != "0x0")
                            {
                                string newString = "" + fieldVal.Substring(i, j) + "";
                                fieldVal = fieldVal.Replace(fieldVal.Substring(i, j), newString);
                                j = newString.Length;
                            }
                            i += j;
                        }
                }
                else
                {
                    if(fieldVal != "0x0")
                    {
                        fieldVal = "" + fieldVal + "";
                        if(field.IsPointerToPointer)
                        {
                            fieldVal += " (pointer to pointer array: ";
                            FileBlock pointed = parsedFile.GetBlockByAddress((field as Field<ulong>).Value); // this is probably a safe cast
                            if(pointed != null && pointed.Size % parsedFile.PointerSize == 0) // probably a pointer
                            {
                                ulong[] pointers = new ulong[pointed.Size / parsedFile.PointerSize];
                                int index = 0;
                                while(index != pointed.Size)
                                {
                                    pointers[index / parsedFile.PointerSize] = parsedFile.PointerSize == 4 ? BitConverter.ToUInt32(pointed.Data, index) : BitConverter.ToUInt64(pointed.Data, index);
                                    index += parsedFile.PointerSize;
                                }
                                string[] temp = pointers.Select(i => { return "0x" + (i == 0 ? "0" : i.ToString("X" + (parsedFile.PointerSize * 2))); }).ToArray();
                                temp = temp.Select(i => { return i == "0x0" ? i : "" + i + ""; }).ToArray();

                                fieldVal += "{ " + string.Join(", ", temp) + " })";
                            }
                            else
                                fieldVal += "...but target doesn't look like a pointer array)"; // probably will crash instead of getting to this
                        }
                    }
                }
            }

            string typeName = field.TypeName + (field.IsArray ? (field.Is2DArray ? "[]" : "") + "[]" : "");
            if(!field.IsArray && field.IsPointer && field.IsPrimitive && (field as Field<ulong>).Value != 0)
            {
                FileBlock associatedBlock = parsedFile.GetBlockByAddress((field as Field<ulong>).Value);
                if(associatedBlock != null)
                    typeName += " (points to " + (associatedBlock.Size == associatedBlock.Count * parsedFile.StructureDNA.StructureList[associatedBlock.SDNAIndex].StructureTypeSize ?
                        parsedFile.StructureDNA.StructureList[associatedBlock.SDNAIndex].StructureTypeName : "raw data") + ")";
            }

            writeTableRow(odd ? "odd" : "even", writer, fieldNumber.ToString(), field.FullyQualifiedName, field.Parent.Parent == null ? "(this)" : field.ParentType, typeName, field.Length > 1 ? field.Size + " * " + field.Length + " (" + (field.Size * field.Length) + ")" : field.Size.ToString(), fieldVal);
        }

        private void writeBodyHead(StreamWriter writer)
        {
            writeTable(writer, null, new[] { "Version Number", "File Blocks", "Structures", "Types", "Names", "Raw Data Blocks" }, "blender_header",
                               false, new[] { parsedFile.VersionNumber, parsedFile.GetBlockList().Count.ToString(), parsedFile.StructureDNA.StructureList.Count.ToString(), parsedFile.StructureDNA.TypeList.Count.ToString(), parsedFile.StructureDNA.NameList.Count.ToString(), parsedFile.RawBlockMessages.Count.ToString() });
        }

        private void writeTable(StreamWriter writer, string[] titles, params string[][] rows)
        {
            writeTable(writer, null, titles, null, false, rows);
        }

        private void writeTable(StreamWriter writer, string[] classes, string[] titles, string id, bool useOddEven, params string[][] rows)
        {
            string data = id != null ? "id=\"" + id + "\"" : "";
            if(classes != null)
            {
                data += " class=\"";
                for(int i = 0; i < classes.Length; i++)
                    data += classes[i] + " ";
                data = data.Substring(0, data.Length - 1) + "\"";
            }
            writeStartTag(writer, "table", data);
            writeTableHead(writer, titles);
            writeTableBody(writer, useOddEven, rows);
            writeEndTag(writer); //

        }

        private void writeTableBody(StreamWriter writer, bool useOddEven, params string[][] rows)
        {
            bool odd = true;
            writeStartTag(writer, "tbody");
            for(int i = 0; i < rows.Length; i++)
                if(!useOddEven)
                    writeTableRow(writer, rows[i]);
                else
                {
                    writeTableRow(odd ? "odd" : "even", writer, rows[i]);
                    odd = !odd;
                }
            writeEndTag(writer); //

        }

        private void writeTableHead(StreamWriter writer, params string[] titles)
        {
            writeStartTag(writer, "thead");
            writeStartTag(writer, "tr");
            for(int i = 0; i < titles.Length; i++)
                writeLine(writer, "" + titles[i] + "	");
            writeEndTag(writer); //

            writeEndTag(writer); //

        }

        private void writeTableRow(StreamWriter writer, params string[] row)
        {
            writeTableRow(null, writer, row);
        }

        private void writeTableRow(string htmlClass, StreamWriter writer, params string[] row)
        {
            string data = htmlClass != null ? "class=\"" + htmlClass + "\"" : "";
            writeStartTag(writer, "tr", data);
            for(int i = 0; i < row.Length; i++)
                writeLine(writer, "" + row[i] + "	");
            writeEndTag(writer);
        }

        private void writeHtmlHead(StreamWriter writer)
        {
            writeStartTag(writer, "head");
            writeLine(writer, "<title>Parsed data for " + friendly + "</title>");
            writeLine(writer, "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />");
            writeLine(writer, "<link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\">");
            writeEndTag(writer); //
        }

        private void writeStartTag(StreamWriter writer, string tag)
        {
            writeStartTag(writer, tag, null);
        }

        private void writeStartTag(StreamWriter writer, string tag, string attr)
        {
            if(attr == null)
                attr = "";
            else if(attr != "")
                attr = " " + attr;

            breadcrumbs.Push(tag);
            writeLine(writer, "<" + tag + attr + ">");
            tabDepth++;
        }

        private void writeEndTag(StreamWriter writer)
        {
            tabDepth--;
            writeLine(writer, "</" + breadcrumbs.Pop() + ">");
        }

        private void writeLine(StreamWriter writer, string text)
        {
            writer.WriteLine(tabs + text);
        }

        private string getValueAsPointerString(Field<ulong> pointer)
        {
            return pointer.Value.ToString("X" + (pointer.Size * 2));
        }

        private string getValueAsPointerArray(Field<ulong[]> pointerArray)
        {
            return "{ " + string.Join(", ", pointerArray.Value.Select(s => s.ToString("X" + (pointerArray.Size * 2)))) + " }";
        }

        // I dislike this function because I can't make it nice and formatted.
        private void writeCSS()
        {
            if(File.Exists("style.css"))
                return;

            using(StreamWriter s = new StreamWriter(File.Open("style.css", FileMode.CreateNew)))
            {
                s.Write(
@"/*
Feel free to edit this file to preference; as long as it exists the utility will not overwrite it.
Just delete it and run the utility to return it to default settings.
*/

table
{
	width:100%;
	margin-top:2px;
}

thead, tr, td, tbody, table, th
{
	border:1px solid;
}

div
{
	width:100%;
	margin-top:15px;
}

thead
{
	background-color:rgb(230,170,170);
}

tr.even
{
	background-color:rgb(190,190,190);
}

tr.odd
{
	background-color:rgb(170,170,230);
}

tr.index .first
{
    text-align: center;
}

tr.index td table
{
    margin: 0;
    border: none;
}

div#container
{
	width:960px;
	margin-left:auto;
	margin-right:auto;
}

table.structure_head tbody tr, table#blender_header tbody tr
{
	background-color:rgb(190,190,190);
}

body
{
	background-color:rgb(230,230,230);
}"
);
            }
        }
    }
}


text:
from temboo.core.choreography import Choreography
from temboo.core.choreography import InputSet
from temboo.core.choreography import ResultSet
from temboo.core.choreography import ChoreographyExecution

import json

class Translate(Choreography):

    def __init__(self, temboo_session):
        """
        Create a new instance of the Translate Choreo. A TembooSession object, containing a valid
        set of Temboo credentials, must be supplied.
        """
        super(Translate, self).__init__(temboo_session, '/Library/Microsoft/Translator/Translate')

    def new_input_set(self):
        return TranslateInputSet()

    def _make_result_set(self, result, path):
        return TranslateResultSet(result, path)

    def _make_execution(self, session, exec_id, path):
        return TranslateChoreographyExecution(session, exec_id, path)

class TranslateInputSet(InputSet):
    """
    An InputSet with methods appropriate for specifying the inputs to the Translate
    Choreo. The InputSet object is used to specify input parameters when executing this Choreo.
    """
    def set_AccessToken(self, value):
        """
        Set the value of the AccessToken input for this Choreo. ((optional, string) A valid access token. This can be retrieved by running the GetToken Choreo. Required unless providing the ClientID and ClientSecret.)
        """
        super(TranslateInputSet, self)._set_input('AccessToken', value)
    def set_Category(self, value):
        """
        Set the value of the Category input for this Choreo. ((optional, string) A string containing the category (domain) of the translation. Defaults to "general".)
        """
        super(TranslateInputSet, self)._set_input('Category', value)
    def set_ClientID(self, value):
        """
        Set the value of the ClientID input for this Choreo. ((conditional, string) The Client ID obtained when signing up for Microsoft Translator on Azure Marketplace. This is required unless providing an AccessToken.)
        """
        super(TranslateInputSet, self)._set_input('ClientID', value)
    def set_ClientSecret(self, value):
        """
        Set the value of the ClientSecret input for this Choreo. ((conditional, string) The Client Secret obtained when signing up for Microsoft Translator on Azure Marketplace. This is required unless providing an AccessToken.)
        """
        super(TranslateInputSet, self)._set_input('ClientSecret', value)
    def set_ContentType(self, value):
        """
        Set the value of the ContentType input for this Choreo. ((optional, string) The format of the text being translated. The supported formats are "text/plain" (the default) and "text/html".)
        """
        super(TranslateInputSet, self)._set_input('ContentType', value)
    def set_From(self, value):
        """
        Set the value of the From input for this Choreo. ((required, string) A string representing the ISO 639-1 language code of the translation text (e.g., en).)
        """
        super(TranslateInputSet, self)._set_input('From', value)
    def set_Text(self, value):
        """
        Set the value of the Text input for this Choreo. ((required, string) A string representing the text to translate. The size of the text must not exceed 10000 characters.)
        """
        super(TranslateInputSet, self)._set_input('Text', value)
    def set_To(self, value):
        """
        Set the value of the To input for this Choreo. ((required, string) A string representing the ISO 639-1 language codee to translate the text into (e.g., es).)
        """
        super(TranslateInputSet, self)._set_input('To', value)

class TranslateResultSet(ResultSet):
    """
    A ResultSet with methods tailored to the values returned by the Translate Choreo.
    The ResultSet object is used to retrieve the results of a Choreo execution.
    """

    def getJSONFromString(self, str):
        return json.loads(str)

    def get_ExpiresIn(self):
        """
        Retrieve the value for the "ExpiresIn" output from this Choreo execution. ((integer) Contains the number of seconds for which the access token is valid when ClientID and ClientSecret are provided.)
        """
        return self._output.get('ExpiresIn', None)
    def get_NewAccessToken(self):
        """
        Retrieve the value for the "NewAccessToken" output from this Choreo execution. ((string) Contains a new AccessToken when the ClientID and ClientSecret are provided.)
        """
        return self._output.get('NewAccessToken', None)
    def get_TranslatedText(self):
        """
        Retrieve the value for the "TranslatedText" output from this Choreo execution. ((string) The translated text parsed from the Microsoft response.)
        """
        return self._output.get('TranslatedText', None)

class TranslateChoreographyExecution(ChoreographyExecution):

    def _make_result_set(self, response, path):
        return TranslateResultSet(response, path)


text:
//
//  ZHChatViewController.m
//  GZHProject
//
//  Created by gzh on 2018/1/16.
//  Copyright © 2018年 gzh. All rights reserved.
//

#import "ZHChatViewController.h"

@interface ZHChatViewController ()

@end

@implementation ZHChatViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
//    会话类型
//    self.conversationType = ConversationType_PRIVATE;
//    对方的id
//    self.targetId = @"1";
//    self.title = @"聊天对象";

}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

/*
#pragma mark - Navigation

// In a storyboard-based application, you will often want to do a little preparation before navigation
- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    // Get the new view controller using [segue destinationViewController].
    // Pass the selected object to the new view controller.
}
*/

@end


text:
namespace blink {

class MediaControlsImpl;

class MediaControlTimeDisplayElement : public MediaControlDivElement {
 public:
  // Exported to be used in unit tests.
  MODULES_EXPORT void SetCurrentValue(double);
  MODULES_EXPORT double CurrentValue() const;

  gfx::Size GetSizeOrDefault() const override;

  virtual String FormatTime() const;

 protected:
  explicit MediaControlTimeDisplayElement(MediaControlsImpl&);

  virtual int EstimateElementWidth() const;

 private:
  void SetAriaLabel();

  double current_value_ = 0;
};

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIA_CONTROLS_ELEMENTS_MEDIA_CONTROL_TIME_DISPLAY_ELEMENT_H_


text:
@interface PlotHostView : UIView
{

}

@end


text:
<!doctype html>

        <meta charset="utf-8">
        <meta http-equiv="x-ua-compatible" content="ie=edge">
        <title>16 documentation</title>
        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial-scale=1">

        <link rel="icon" type="image/x-icon" href="../images/favicon.ico">
	    <link rel="stylesheet" href="../styles/style.css">

            16 documentation
            <button type="button" class="btn btn-default btn-menu fa fa-bars" id="btn-menu"></button>

                <input type="text" placeholder="Type to search">

                        16 documentation

                        Getting started

                                        Overview

                                  README

                                        LICENSE

                                Modules

                                    AnalyticsModule

                                    CoreModule

                                    MultilingualModule

                                    PuzzleModule

                                    SampleModule

                                    SharedModule

                                    WebModule

                            Components

                                    AboutComponent

                                    AppComponent

                                    FooterComponent

                                    HomeComponent

                                    LangSwitcherComponent

                                    NavbarComponent

                                    PuzzleComponent

                                    ToolbarComponent

                                    ToolbarComponent

                            Directives

                                    PlatformDirective

                            Classes

                                    Analytics

                                    BaseComponent

                                    BaseService

                                    Board

                                    ChangeAction

                                    Config

                                    ConfigMock

                                    ConfigMockMultilang

                                    ConfigRecord

                                    DesktopConfig

                                    ElectronEventService

                                    LangChangedAction

                                    LangUnsupportedAction

                                    LogTarget

                                    LogTargetBase

                                    LogTargetOptions

                                    MockPopStateEvent

                                    PuzzleConfig

                                    Row

                                    Square

                                    TranslateLoaderMock

                                    TranslateMock

                                    Utils

                                    WindowMock

                                    WindowMockFrench

                                    WindowMockNoLanguage

                            Injectables

                                    ActionsService

                                    AnalyticsService

                                    AppService

                                    BoardService

                                    ConsoleService

                                    ConsoleTarget

                                    LocalStorageService

                                    LogService

                                    MockLocationStrategy

                                    MultilingualEffects

                                    MultilingualService

                                    NameListService

                                    PuzzleStateService

                                    RouterExtensions

                                    RouterExtensionsMock

                                    SampleEffects

                                    StateService

                                    StorageService

                                    WindowService

                            Interfaces

                                    ActionsServiceInterface

                                    DatabaseServiceInterface

                                    EnvConfig

                                    ExtendedNavigationExtras

                                    IAnalytics

                                    IAnalyticsProperties

                                    IAppState

                                    IConsole

                                    ICoreModuleOptions

                                    IEvent

                                    ILang

                                    IMultilingualActions

                                    IMultilingualState

                                    IPlatforms

                                    IRouterExtensions

                                    ISampleState

                                    IStorage

                                    IWindow

                                    LogEvent

                                    ModelInterface

                                    StateServiceInterface

                                    TestApi

                                    ToolbarInterface

                                    ToolbarOptionsInterface

                            Miscellaneous

                                  Enums

                                  Functions

                                  Type aliases

                                  Variables

                        Documentation coverage

                            Documentation generated using

                               16 documentation

                                   <input type="text" placeholder="Type to search">

                               Getting started

                                               Overview

                                         README

                                               LICENSE

                                       Modules

                                           AnalyticsModule

                                           CoreModule

                                           MultilingualModule

                                           PuzzleModule

                                           SampleModule

                                           SharedModule

                                           WebModule

                                   Components

                                           AboutComponent

                                           AppComponent

                                           FooterComponent

                                           HomeComponent

                                           LangSwitcherComponent

                                           NavbarComponent

                                           PuzzleComponent

                                           ToolbarComponent

                                           ToolbarComponent

                                   Directives

                                           PlatformDirective

                                   Classes

                                           Analytics

                                           BaseComponent

                                           BaseService

                                           Board

                                           ChangeAction

                                           Config

                                           ConfigMock

                                           ConfigMockMultilang

                                           ConfigRecord

                                           DesktopConfig

                                           ElectronEventService

                                           LangChangedAction

                                           LangUnsupportedAction

                                           LogTarget

                                           LogTargetBase

                                           LogTargetOptions

                                           MockPopStateEvent

                                           PuzzleConfig

                                           Row

                                           Square

                                           TranslateLoaderMock

                                           TranslateMock

                                           Utils

                                           WindowMock

                                           WindowMockFrench

                                           WindowMockNoLanguage

                                   Injectables

                                           ActionsService

                                           AnalyticsService

                                           AppService

                                           BoardService

                                           ConsoleService

                                           ConsoleTarget

                                           LocalStorageService

                                           LogService

                                           MockLocationStrategy

                                           MultilingualEffects

                                           MultilingualService

                                           NameListService

                                           PuzzleStateService

                                           RouterExtensions

                                           RouterExtensionsMock

                                           SampleEffects

                                           StateService

                                           StorageService

                                           WindowService

                                   Interfaces

                                           ActionsServiceInterface

                                           DatabaseServiceInterface

                                           EnvConfig

                                           ExtendedNavigationExtras

                                           IAnalytics

                                           IAnalyticsProperties

                                           IAppState

                                           IConsole

                                           ICoreModuleOptions

                                           IEvent

                                           ILang

                                           IMultilingualActions

                                           IMultilingualState

                                           IPlatforms

                                           IRouterExtensions

                                           ISampleState

                                           IStorage

                                           IWindow

                                           LogEvent

                                           ModelInterface

                                           StateServiceInterface

                                           TestApi

                                           ToolbarInterface

                                           ToolbarOptionsInterface

                                   Miscellaneous

                                         Enums

                                         Functions

                                         Type aliases

                                         Variables

                               Documentation coverage

                                   Documentation generated using

Classes

Analytics

        Info

        Source

File

            src/client/app/modules/analytics/services/analytics.service.ts

Description

Base class
Standardizes tracking actions and categorization

Implements

                        IAnalytics

Index

Properties

                                        Public analytics

                                        Public category

Methods

                                         track

Constructor

                                    constructor(analytics: AnalyticsService)

Defined in src/client/app/modules/analytics/services/analytics.service.ts:81

                        Methods

                                     track

            track(action: string, properties: IAnalyticsProperties)

Defined in src/client/app/modules/analytics/services/analytics.service.ts:90

Track actions, events, etc.

                                            Returns :     void

                        Properties

                                    Public analytics

                                    analytics:     AnalyticsService

                                        Type :     AnalyticsService

                                        Decorators : Inject

Defined in src/client/app/modules/analytics/services/analytics.service.ts:83

                                    Public category

                                    category:     string

                                        Type :     string

Defined in src/client/app/modules/analytics/services/analytics.service.ts:81

import { Injectable, Inject } from '@angular/core';

import * as _ from 'lodash';
import { Angulartics2, Angulartics2Segment } from 'angulartics2';

export interface IAnalyticsProperties {
  category?: string;
  label?: string;
  value?: number;
}

export interface IAnalytics {
  track(action: string, properties: IAnalyticsProperties): void;
}

/**
 * Wrapper for Angulartics2
 */
@Injectable()
export class AnalyticsService implements IAnalytics {

  constructor(private angulartics2: Angulartics2, private segment: Angulartics2Segment) {
    // options
    // https://github.com/angulartics/angulartics2/blob/master/src/core/angulartics2.ts#L90-L104
    /*tics2.virtualPageviews(value: boolean);
    tics2.excludeRoutes(routes: Array<string>);
    tics2.firstPageview(value: boolean);
    tics2.withBase(value: string);*/

    this.devMode(false);
  }

  /**
   * Track actions, events, etc.
   **/
  public track(action: string, properties: IAnalyticsProperties): void {
    if (!this.devMode()) {
      this.segment.eventTrack(action, properties);
    }
  }

  /**
   * Called automatically by default with Angular 2 Routing
   * However, that can be turned off and this could be used manually
   **/
  public pageTrack(path: string, location: any) {
    if (!this.devMode()) {
      this.segment.pageTrack(path, location);
    }
  }

  /**
   * Identify authenticated users
   **/
  public identify(properties: any) {
    if (!this.devMode()) {
      this.segment.setUserProperties(properties);
    }
  }

  /**
   * Control whether analytics are tracked
   * true: dev mode on, therefore do not track anything
   * false: dev mode off, track everything
   **/
  public devMode(enable?: boolean): boolean {
    if (typeof enable !== 'undefined') {
      this.angulartics2.developerMode(enable);
    }
    return this.angulartics2.settings.developerMode;
  }
}

/**
 * Base class
 * Standardizes tracking actions and categorization
 */
export class Analytics implements IAnalytics {
  // sub-classes should define their category
  public category: string;

  constructor(@Inject(AnalyticsService) public analytics: AnalyticsService) {

  }

  /**
   * Track actions, events, etc.
   **/
  track(action: string, properties: IAnalyticsProperties): void {
    this.analytics.track(action, _.extend(properties, { category: this.category }));
  }
}

 results matching ""

No results matching ""