text:
title: What Is Centrality?
description: What Is Centrality?
name: Centrality
author: WeUseCoins
permalink: /what-is-centrality/
authorurl: /
published: true
toc:
  what: What Is Centrality?
  getting: Getting Started With Centrality
  howto: How To Get A Centrality Wallet?
  resources: Centrality Resources
  buy: How To Buy Centrality?
  mining: What Is Centrality Mining?
  latest: Latest Centrality News
img: centrality.png
category: altcoin
summary: Centrality is a venture studio that partners with leading innovators in key industries to create a marketplace of applications. These applications allow consumers to manage everyday tasks and experiences using peer-to-peer transactions – all via one login and using blockchain-enabled infrastructure.
---

What Is Centrality?

They're a venture studio that partners with leading innovators in key industries to create a marketplace of applications. These applications allow consumers to manage everyday tasks and experiences using peer-to-peer transactions – all via one login and using blockchain-enabled infrastructure.

They're one of the leading, blockchain venture studios in the world, with a growing team of 75 people across Auckland, London, Melbourne and Singapore. They're backed by a global investor network who understand our vision – to help the world transition to a blockchain-enabled future.

Purpose Meets Opportunity

Schumpeter's hypothesis that technology would only serve to concentrate ownership and wealth towards large corporations now seems prophetic1 . Given the early promise of the internet era, it is lamentable that the bifurcation of income between the 'haves' and the 'have nots' has become even more profound during the internet age.

Despite market growth and increased prosperity, the vast majority of traditional tech startups fail and the odds of their success are infinitely small even if they are executed well. Adam Smith's invisible hand is powerless against the tech giants.2 Their significant head-start on data gives an application of artificial intelligence (AI) the potential to increase the scale of inequality and reduce basic human rights to a free and democratic society

{% include page-toc.html %}

We know a potential revolution is on the horizon as we escape the gravitational pull of the PC internet era. The internet has come, it saw and it conquered us all with the data-mining-foradvertising model. The PC internet era had a baby and that baby is the decentralized Blockchain. Distributed networks on blockchain have the ability to transform the world of traditional apps, technology models, business models, and economic models across the entire planet - right now.

While there is great promise, there is also a problem with Blockchain that is not commonly acknowledged. The problem is that there are hurdles that make the technology elusive for early stage companies and hard to adopt for regular users. Most Blockchain use cases are still in development and unproven. Furthermore, many of these use cases are in areas an average user would be hard pressed to engage with. Transactions are anonymous, so data has limited value without context or relevance. This makes it difficult to employ critical technology such as big data and machine learning in a world where these technologies are set to dominate the landscape.

Mission Impossible for Traditional Startups

Despite the challenges, the number of new online startups continues to grow and low barriers to entry create a huge fragmentation of effort. Consequently, very few startups achieve scale. At the same time, users are interacting with fewer applications and their expectations are very high. The capability a new startup needs to meet these expectations is almost impossible to achieve.

Digital business models are often highly reliant on data mining for advertising and newcomers are starting from a very disadvantaged position compared to incumbents. Ubiquitous platforms are rapidly consuming new niches with their bigger, multi-disciplined and agile teams and access to data anticipating market movements.

Two key factors are working against market entrants achieving scale. Firstly, the number of digital start-ups out there is rapidly expanding, fragmenting user attention, capital and technical resources. Secondly, bigger platforms have a huge lead in user data, attention, capital and resource, which enables them to either predict what's coming or copy very fast.

On average, good plans, people, and businesses succeed only 1 in 10 times. This is because there are many components that are critical to an enterprise's success. The best companies might have an 80% probability of succeeding at each of them. But even with these odds, the probability of eventual success will be less than 20% because failing to execute on any one component can torpedo the entire company.

The reality is in this model, a very small percentage of people own and/or control all the assets and the system, in which the other 99% are effectively modern day serfs to their feudal kings and queens4 . Therefore, the holy grail and guiding purpose for Centrality Investments Limited (Centrality or Centrality Investments) is to provide a platform that will create a decentralized community of digital startups, successful in a world where the odds are otherwise stacked against them.

In graph theory and network analysis, indicators of centrality identify the most important vertices within a network of decentralized points. Applications include identifying the most influential person(s) in a social network, key infrastructure nodes in the internet or urban networks.

The Centrality Platform described in this White Paper allows developers and entrepreneurs to find and create these connections between their applications and to create actions which join them together in new degrees of closeness.

Centrality currently has 8 apps in market, generating revenue with a rapidly increasing user base. Many of these applications have partnerships with listed companies and major corporations to help accelerate growth. The Centrality Platform is already proving the benefits of sharing of data, users, merchants and insights to these apps. This is creating lower acquisition costs and faster scaling.

Barriers to Mainstream Adoption of Blockchain

Blockchain technology has the power to transform the way industries operate around the world. Many Blockchain companies are very technology-driven or trading- and fintech-centric. There is virtually no mainstream consumer adoption as the concepts are not familiar and the user experience and interface are quite technical.

Even if a company decides to develop on the Blockchain, the talent pool is limited and very few startups can access the talent required to create robust solutions.

Many ICOs to date have been very theoretical and overtly ambitious with little real world proof of their 11 value. The high failure rates are hardly a surprise and likely to continue considering the limited practical use cases and user engagement strategies. This in itself represents a substantial risk to the ecosystem and consumer adoption.

Blockchain companies, while often ambitious about their desire to change the system and create a more distributed and decentralized world, are often following the same economic model as their PC internet era startup companies in reality.

For example, they tend to:

1. reproduce the boiler plate for each application over and over

2. require the user to onboard over and over again

3. follow similar isolated value creation models and customer information silos as their incumbent competitors

4. result in fragmented capital, human resources and user attention

The Solution: A New Startup Life Cycle

The Centrality Platform is an ecosystem platform that supports each stage of the startup life cycle. It takes a human-centric approach that allows users to interact with a range of different applications with very low friction. The Centrality Platform allows developers to create applications which leverage the combined scale of the ecosystem in order to beat the incumbent startup hurdles that exist today.

Technology alone does not have the power to overcome the momentum that the incumbent technology companies have, and with the advent of machine learning these incumbent companies are extending their advantage at exponential rates. Without a radical shift in the way the economic model behind a startup works, and without working in a different way to the typical startup model, the landscape is unlikely to change.

Centrality's direct customers are smart entrepreneurs who are trying to disrupt traditional value chains and concepts by implementing Blockchain technology.

The major advances in application development have been driven by platforms such as AWS and AZURE, providing developers with tools, services, APIs and applications which enable them to focus on the value-creating parts of the technology stack and user experience.

However, this has further concentrated power to the platform owners which have rapidly consolidated. Imagine a world where the developers and customers harness the benefits from the services provided by a platform like AWS and the value the applications create, instead of that benefit being concentrated in a single central entity.

Centrality has built a platform, services and a library of applications that can be used as building blocks to create a decentralized application ("DApp") business. This component-based design gives startups flexibility over their product, while ensuring a standardised look and feel across all Centrality Platform DApps. By standardising design for all scenes, it provides participants with a clean user experience across the ecosystem.

{% include page-toc.html %}

This component library allows start-ups to access all of the tools from the Centrality Platform toolkit, including Login with Blockchain, Hybrid Wallet, Blockchain Everywhere, API / SDK, Common Microservices, Big Data Platform, Smart Contract Generator and Token Factory.

In addition to these tools, users can seamlessly move between applications without being subjected to traditional approaches to customer application onboarding. This creates a network of interconnected DApps that users can transition between in a human-centric way.

Being part of the Centrality Platform allows start-ups to create commercial connections using smart contracts with other DApps who will help them grow. This avoids the cost and speed implications of traditional commercial integrations and partnerships.

The Centrality Platform helps Blockchain developers circumvent the startup model by:

1. Providing a place to incubate their DApp on a consortium platform where constraints of performance and cost associated with public chains don't exist

2. Providing the boilerplate services to get their applications up and running fast with minimal effort

3. Providing a market place for different applications to share in the user pool, the data pool, the merchant pool, and the content pool across the platform to overcome traditional 'chicken and egg' scale issues

4. Enabling a machine learning framework that can help connect users in one application to a relevant experience in another in real time to increase engagement

5. Enabling decentralized applications to be built TGE (ICO) ready with integrated assessment/advisory investment banking support services

6. Providing access to post TGE services such as exchange listing, ongoing reporting and performance monitoring

The Economic Model

Centrality has partnered with a number of marketplace use cases that will prompt consumers and brands to transact with and through the Centrality Platform. Through experimentation, Centrality Platform plans to iterate on the product with applications that create unique three-sided marketplaces for users, developers and investors. On the supply side, both bots or content creators will create unique experiences. On the demand side, users will consume these products or services.

Centrality turns the traditional funding method on its head. Traditionally when somebody invests money into a business, that money is used to build technology from scratch. This often results in duplication of components that already exist elsewhere, making it hard to scale efficiently without a huge investment.

With the Centrality Platform, the startup's dollar goes further because it gains access to a network, lowering the cost of acquisition per user, accelerating growth and providing a better, lower risk return.

The Centrality Platform aims to solve the issues with Schumpeter's hypothesis by ensuring that every participant in the ecosystem will gain value from their participation.

In the future, each time an application introduces a new user into the ecosystem, and that user transacts with other DApps the original application that originated that user will be recognized with CENNZ.

Each application created will allocate a number of their initial tokens to Centrality Platform, and Centrality Platform will have the discretion to airdrop these to the holders of CENNZ tokens.

The 'Centrality Effect' will mean both users and DApps who hold CENNZ tokens share the utility created by the Centrality Platform. Everyone is incentivized to continue to drive activity to share in the mutual success.

The Scene companies must pay Centrality Platform an access fee denominated in CENNZ tokens to access the Centrality Platform. In addition, Centrality Platform will earn revenue denominated in CENNZ tokens from developers who pay to use platform services in their applications. Centrality Platform also shares in the value of the ecosystem's token basket by receiving an allocation of each DApp's native tokens (if they are issued).

Monetization of the different platform layers

Technology Approach

We have created a platform that helps applications become a part of the Blockchain and have wide spread consumer adoption by building a range of components that overcome multiple hurdles.

Getting Started With Centrality

Centrality is a blockchain platform and venture studio business based in Auckland New Zealand, with offices in 4 countries around the world. Centrality builds the CENNZ network and CENNZ software tools. Centrality also helps developers build applications on top of the network.

Centrality is building a platform to enable a more equal and fair world for all users. Right now, your data is owned by 4 big internet companies and they use it to make huge profits – they also use their power to shut down competition. We believe the Centrality marketplace will put people back in control of their data and allow smaller companies to succeed by working together, this allows for a fairer world for everyone.

Centrality was formed by a world leading team of entrepreneurs with significant experience in developing technology and payments business. Several of the team have managed and built billion-dollar business. The technical team come from leading tech companies, blockchain companies and universities such as Alibaba, Baidu, XERO, Google, IOTA, HYPERLEDGER, Consensys and the Max Plank institute.

{% include page-toc.html %}

Centrality is also partnered with large corporate clients, such as banks, airlines, fast food chains, global payments providers, insurance companies, logistics and shipping companies, advertising and media companies and governments. In addition, Centrality develops applications for world leading blockchain companies such as SingularDTV and Blockhaus.

Centrality has 70 world class engineers and business people.

CENNZ is a world-first, integrated network of blockchain applications. These applications all work together to help each other grow, creating a powerful one-of-a-kind marketplace of applications, all using the CENNZ token. Centrality is different to many blockchain companies who sell their tokens before they have built any technology or created any real users. Centrality has a portfolio of applications, many which are already working and generating revenue. All of these applications will quickly start using the CENNZ network and building value together.

The existing founders, investors and developers who have been working on Centrality over the last 18 months, and have invested personally, will receive 25% of the tokens to continue to motivate them to see the project through to success. An additional 5% of the token supply is retained by the platform to fund initial operations.

The founder and developer tokens will be subject to a lockdown period of 24 months – during this time the tokens will not be able to be traded. The team will not directly receive the ETH raised from the token sale, this will be managed by an independent board to manage the platform investment in the best interests of the token holders. An independent director will be appointed to the Board of Centrality Platform Limited at the conclusion of the main sale.

Centrality Platform Works

The Centrality Platform creates the technological 'foundation' for DApps. Centrality Platform will receive an allocation of any tokens issued by each application it powers in return for delivering the core technology and ecosystem. Developers create modules to add to the service catalogue that the Centrality Platform provides.

Various DApps plug into the Centrality Platform. Each DApp uses the CENNZ token to purchase modules for their app, create connections to users, data, content, merchants, and tokens in the ecosystem.

DApps across different use cases work together to acquire users, data, merchants and content. The use of smart contracts across the Centrality Platform ensures different companies can trust each-other.

Each DApp is 100% focused on creating its own businesses, partnering and on-boarding users, whilst Centrality Platform focuses on powering the core technology and design.

Proven Business Model

Centrality has already proven the business model and technology. Within 6 months of being established, Centrality delivered its platform technology phase 1 and received a stake in more than 10 real applications. These businesses are at varying levels of maturity, with several generating combined revenue in the multi-million dollar range.

Centrality raised over 40,000 ETH in its pre-sale to continue to expand its network around the world.

Centrality has received a non-refundable research grant from the New Zealand Government of up to $15m over 3 years.

Centrality has also formed strategic development partnerships with top tier blockchain companies such as SingularDTV and Blockhaus AG.

Centrality in Action

Centrality has been able to connect a range of applications to the Centrality Platform that are both DApp and hybrid using "Blockchain Everywhere" micro services. This solution allows developers to deliver a wide range of block chain connected use cases that a user would consume on a daily basis, without having to compromise on the quality of experience nor the application performance.

These applications are grouped into one of ten 'Scenes' with the aim that a consumer will interact with at least one application in each scene and to create their own group of DApp experiences they can use to navigate.

App Boosting

Different applications on the Centrality Platform can help each other grow by connecting users to relevant services across the ecosystem. Applications can lower their costs of scaling by sharing from the marketplace of services, merchants, content and user.

On Demand UI

When applications are developed with the Centrality Software Development KIT ("SDK") on the Centrality Platform, a user can transition between and transact with different applications or services seamlessly without needing to download or install another application from the app store, sign-in, or create a profile.

In the example below, a Belong customer has provided its staff with a discounted ticket to an event as a reward. Belong has connected with another Centrality powered application, UShare, a 16 decentralized multi-modal, real time, transport application. The app connector tool allows Belong to offer a ride to the event via UShare.

When the user clicks on this option the full UShare native application is installed on the fly, in less than 5 seconds in their current app interface and populated with the user's profile, wallet, meta data from their profile.

The user can now book the ride without having to install from the app store, create a profile, add payment details or insert the address of their destination.

Belong and UShare both share in the upside of this connection via a smart contract they created.

The Centrality Platform's Existing Marketplace

Skoot is a travel experience marketplace with a virtual companion designed for inbound visitors and free independent travelers. It uses patented technology to help users find interesting things to do, drive safely and stay connected to their loved ones whilst on the move.

Skoot also helps affiliate partners such as rental vehicle and camper hire companies generate new revenue opportunities as well as improving operational efficiency with data gathered in-vehicle. The Skoot marketplace allows traditional tourism operators to streamline their supply chains and enables a peer to peer market place for individuals to offer experiences in their spare time.

Centrality owns 50% of Skoot.

Belong is an employee engagement platform and marketplace which helps businesses provide rewards (or 'perks') for employees, including a non-fiat currency to enable non-salary based incentives. Belong also has a powerful financial services engine for managing group and personal insurance plans, claims and entitlements. Belong acts as a digital brokerage, leveraging its unique employer-provided user insights to target and sell.

Centrality owns 25% of Belong.

UShare is a multi-modal on demand transport application. UShare works across taxi services, rental vehicles, electric bikes and public transport. UShare is changing the way ride sharing works by creating a modern day co-operative between providers and users. As providers provide services, they earn tokens in the ecosystem creating an ongoing revenue stream as technology evolves into automated services.

Centrality owns 25% of UShare.

Merge is a time management system for city dwellers. Simply tell Merge when you want to leave, or when you want to arrive at your destination. Set when you'd like to get notified and Merge will let you know when it's the best time to go. Merge uses smart technology and an incentive model to schedule the time users travel to maximize the throughput of a network. Merge enables a real-time vehicle insurance model.

Centrality owns 100% of Merge.

FeedMi is a DApp that lets you jump in the queue for busy restaurants, from anywhere you want, pay right from your table, and order pick up or home delivery.

FeedMi enables restaurants to improve their profitability by offering real time demand management and insights to help optimize their business. On average a venue can save $30,000 per year in costs.

Centrality owns 25% of FeedMi.

SingularX is a distributed cryptocurrency and token trading platform. SingularX lets users trade crypto assets, make markets and convert crypto currencies. Because SingularX is not a centralized exchange, it is resilient to service-disrupting attacks and fraud.

Centrality owns 50% of SingularX

Blockhaus is building the world's leading Blockchain-based financial investment banking platform for tokenised ecosystems. The Blockhaus consortium was founded by the people behind the global powerhouses in global Blockchain, MME and SingularDTV.

Centrality developed the Blockhaus investment banking technology.

Pocketpos is a merchant point of sales aggregator providing access to run campaigns, offers and vouchers and payments to businesses and have them redeemed at thousands of retailers and vendors own point of sales (POS) solutions. This allows users to complete the purchase loop with cryptocurrencies directly with retailers own POS software without having to integrate directly.

Centrality owns 100% of Pocketpos.

Aimy is changing the way you approach health and wellbeing. Aimy gives you the freedom to workout on your own terms. The app helps you challenge like-minded training partners and find fitness experts and activities that match your profile.

Aimy is a decentralized machine learning coach. Aimy can run totally independently from the internet and if you choose, can send zero knowledge data to the cloud to help improve the AI which is pushed out to the clients.

Aimy rewards participants for helping train it further. Aimy can help optimise insurance pricing for its users. Aimy is powered by patented technology from ARDA.AI the world leader in virtual coaching and Centrality owns 10% of the company that owns Arda, Performance Lab Technologies Limited.

Centrality owns 90% of AIMY.

City On is the consumer proposition for the smart city platform enabling user-centric commerce activations by merchants, promoters and brand partners. It is an aggregator of city services and applications including direct events, food and beverage, experiences, health, fitness, venue, transport, parking, rideshare, bike share and brand partnerships.

{% include page-toc.html %}

It is an application designed to help make it easy to get around the city, find interesting things to do, as well as book and pay for them. City On is 51% owned by QMS (ASX Listed) who will leverage City On to connect users to its substantial APAC outdoor and transport media assets.

Centrality owns 49% of City On.

PayCheck helps companies pay their teams in crypto currencies. Schedule payments and automatically convert currency on the fly for the user.

Centrality owns 30% of PayCheck.

Blockeeper helps blockchain companies comply with tax regulation by connecting their transactions to popular accounting software. Blockeeper can act as a standalone book keeping service to keep track of payments and cashflows.

Centrality owns 30% of Blockeeper.

The Centrality Platform Modules

Hybrid Consortium Chain - The Ethereum network currently operates on a Proof of Work Blockchain. Future versions of Ethereum will work to improve throughput and scalability. The current average or block time is approximately 17 seconds.

The number of daily transactions on the Ethereum network has been growing. Currently, the number of daily transactions is as high as 1,000,000, with costs over $2 per transaction and wait times over 2 mins for conformation and this volume is expected to continue increasing as new applications and users continue to enter the Ethereum ecosystem.

The current throughput of Ethereum is approximately 8.5 transactions per second or approximately 740,000 daily transactions. Over time, the Ethereum network can also adjust to higher volume conditions for additional throughput.

Ethereum transaction confirmation times result in an application experience that mainstream users are not typically familiar with. Ethereum Blockchain requires fees to be paid for every transaction. Fees are paid in Ether cryptocurrency, creating an adoption barrier for the average user.

The Centrality Platform has implemented and runs a consortium chain based on Ethereum with several improvements for better performance and security. The design will (1) reduce latency and congestion, (2) avoid network fees when creating transactions, and (3) avoid stress on the public network due to large transaction volumes.

Blockchain Everywhere Microservices - With a complex set of applications across the Centrality ecosystem, not all applications are comprised 100% of services which are suited to operating in a DApp context. For example, it wouldn't be practical to capture, write and process all the data for a real-time ride share matching service. However, these services need to be able to interact with Blockchain services in order to form a cohesive application and user experience.

In the Centrality ecosystem, all services have their own private key and public address. They can interact with the chain (event), store data and retrieve data from the chain. This also provides the mechanism for secure communication. Data storage will depend on the application's requirements, with a bias towards storing in-chain where it makes sense to the user experience and economic model. This allows developers to build complex services that can transparently interact with pure Blockchain components.

Token Factory - In order to facilitate the graduation from the Centrality consortium chain into a public chain application or its own TGE, each application will be encouraged to create a native token when joining the Centrality Platform. These tokens will be ERC20 compatible, which support the interaction and standards with the existing infrastructure of the Ethereum ecosystem.

Once an application wishes to enter the main chain, their "pre token" can be exchanged for a new token if the token owners wish to change the structure of the token.

Login with Blockchain - In order to enable users to move seamlessly between DApps within the ecosystem and to carry their profile data to new interactions, a single user profile is required.

That user's unique Ethereum address will be the user's ID throughout the whole ecosystem.

Users will always own their own personal information. When a user signs up, their profile will be created and stored on the chain via a smart contract. This smart contract address will be given to the user. When a user wants to access a new DApp they just need to click the onboard button and the platform will supply the profile address to the new DApp.

DApps always have the latest user information. When a user updates their profile, they only need to update the information inside the existing smart contract, rather than updating each app individually.

Login with Blockchain allows users to use their Blockchain profile to connect to non Blockchain applications

Hybrid Wallet - The Hybrid Wallet is the portal to the decentralized world. The Centrality Platform has developed a hybrid wallet which operates both as a traditional fiat currency payment wallet and a cryptocurrency wallet. This wallet can work inside a DApp or traditional platform application, allowing businesses to transition their user base to Blockchain enabled platforms smoothly.

Checkout, Shopping Cart, Wishboard - Centrality has created a shopping cart and checkout module that allows for a combination of fiat and cryptocurrency payments including real time conversions. Centrality Platform shopping carts follow the user between applications. It is the user's cart, as opposed to belonging to the application. Any products from any application can be combined into a single shopping cart.

User Onboarding Wizards and User Management Console - Centrality has created modules to allow applications to onboard users and performs user management, permissions controls and reporting.

Content, Inventory Management and Creation - Centrality has created modules to allow the creation, management and publishing of content and inventory blocks. Attributes can be assigned to these blocks and they can then be combined to create a wide range of products and offer types. Content, blocks and products can be shared amongst the different applications.

Big Data and Machine Learning interface - One of the keys to startup success is meaningful data. Currently, all Blockchain data is anonymous and analysis on the chain is very slow. Centrality's Big Data engine enables applications to provide reporting, data analysis, machine learning and artificial intelligence services to users where these users have consented to this.

API and SDK - In order to enable users to move between applications instantly, without the need to visit an app store, we have designed an SDK that allows developers to create applications which interact across the marketplace. This helps maintain a consistent user experience across the ecosystem for common components.

Platforms are successful when there is a commonly understood user experience. Users already have a learning curve to understand the way DApps work. Like Apple has shown, providing a common design language for users across many applications will help Blockchain applications establish mainstream scale. This React & React Native (Javascript ES6) compliant SDK includes wallet features (balance, transfer, sign & receive etc), identity and a user profile SDK for getting user's profile, authentication, interaction with DApps.

Application Marketplace - Centrality applications will be more successful when they work together to grow the ecosystem. The application marketplace will allow the creators of different applications to create connections between each other where there is mutual benefit. For example, a ride hail application may work with a food ordering application to reach more customers or reduce the cost of delivery.

App Connector Engine - In order to connect different applications together, a flow will need to exist between them. The Centrality SDK will allow different applications to specify where they want to flow from one process in their application to a different process inside another application.

Smart Contract Generator - To allow different applications to trust each other in marketplace, Centrality allows different applications to create commercial relationships with each other via smart contracts. A range of template contracts will be available or new contracts can be designed and provided to the marketplace by developers.

How To Get A Centrality Wallet?

Centrality is a wander studio that accomplices with driving pioneers in different enterprises to make a commercial center of uses. These applications permit clients oversee every day errands and encounters utilizing shared exchanges, through a solitary login and utilizing blockchain innovation.

{% include page-toc.html %}

The organization, Centrality is one of the main blockchain wander studios comprehensively. It is comprised of a group of 75 individuals situated in Melbourne, Singapore, Auckland, and London. They are a worldwide system of financial specialists who are driven by a solid vision. The organization's vision is to push the world move to blockchain innovation.

Not at all like other blockchain stages which pitch their tokens to raise reserves for their activities, Centrality as of now had a broad arrangement of more than 20 applications which were at that point being used, producing critical incentive before the token deal.

The applications all cooperate to enable each other to develop, building an exceptional application commercial center that uses a standard token; the CENNZ token.

Secure Centrality (CENNZ) Hardware Wallet:

Cryptocurrency Exchanges are always on hackers radar, so it's always safer to keep your cryptocurrency in a wallet.

Ledger Nano S

Security

Supports Multi-Currency

Built-in Display

Multi Apps

Backup & Restoration

Centrality Resources

Official Website

Facebook

Twitter

LinkedIn

Medium

How To Buy Centrality?

CENNZ Tokens

Centrality Platform Pte. Limited (referred to hereinafter as the "Issuer") will issue fully-functional ERC20 'utility' tokens CENNZ main tokens (the "CENNZ tokens" or "CENNZ") in a smart-contract based TGE.

CENNZ is the native token of the Centrality Platform. CENNZ will be used to help connect applications built on the Centrality P latform modules, linking the customer information to different processes. CENNZ is also the fuel for the Centrality ecosystem, used to access the network services, purchase modules to build applications from and to enter commercial agreements between application developers assured by smart contracts.

Utility: CENNZ is a utility token in the sense that you need CENNZ to operate many of the modules/applications in the Centrality ecosystem and to create smart contracts with other applications.

Recognition payments: DApp ("DApp X") may make transfers of CENNZs to another DApp ("DApp Y") in recognition for DApp Y originating users onto the Platform which enter into transactions on DApp X. Access and associated services will be provided to CENNZ holders, and such recognition payments in CENNZs will be effected, in each case by the automatic execution of smart contracts.

Shared Success: CENNZ holders have the ability to share in the success of each individual DApp by being allocated the Issuer's Scene Companies native tokens by air drop on a discretionary basis. This allows all CENNZ holder to participate in the success of the each DApp in the ecosystem.

Implementation and ERC20

CENNZ will be implemented on the public Ethereum Blockchain as an ERC20 token.

The Ethereum Blockchain is currently the industry standard for issuing custom digital assets and smart contracts. The ERC20 token interface allows for the deployment of a standard token that is compatible with the existing infrastructure of the Ethereum ecosystem, such as development tools, 31 wallets, and exchanges. Ethereum's ability to deploy Turing- complete trustless smart contracts enables complex issuance rules for cryptocurrencies, digital financial contracts, and automated incentive structures.

Features and Functionalities of the CENNZ tokens

CENNZ tokens will entitle holders to the following rights:

1. the right to access the Centrality Platform, as detailed in the How the Centrality Platform works section of their White Paper;

2. the right for holders' decentralized blockchain applications' (also referred to as DApps) to access the Centrality Platform and related services, including services provided by other Dapps, provided that the monthly access fee in CENNZ is paid to the Issuer;

3. the opportunity (but not right or entitlement) to receive an airdrop of the Issuer's allocation of the Scene Companies' own native tokens (the "Scene Tokens") generated in their own future token generating events if the Issuer exercises its discretion to make an airdrop.

Please note :

(a) CENNZ token holders will have no legal or beneficial ownership of the intellectual property comprising the Centrality Platform, nor in the shares or other assets of the Issuer. CENNZ tokens are not designed to be securities and do not constitute, nor are they characterised as, any of the Singapore Regulated Products.

(b) For the avoidance of doubt, this White Paper, and the information contained in it and any information accompanying it, are not, and are under no circumstances to be construed as an offer to sell or issue, or a solicitation of an offer to purchase or subscribe for, any Scene Tokens.

CENNZ tokens are also subject to the selling restrictions described more specifically in the 'Important Information' section in the beginning of this White Paper, including:

1. that no person who subscribes for CENNZ tokens in the TGE will sell, dispose or otherwise distribute CENNZ tokens prior to the Release Date, except in the circumstances described in the section "Wholesale Investor warranties and selling restrictions"; and

2. that no person who subscribes for CENNZ tokens in the TGE will sell, dispose or otherwise distribute CENNZ tokens to any person who is not a wholesale investor within the meaning of clause 3(2) of schedule 1 of the FMC Act.

In the TGE subscription agreement, each applicant for CENNZ tokens indemnifies the Centrality Entities for any loss, cost, liability or expense sustained or incurred by the Centrality Entities as a result of the breach by it of these selling restrictions.

Overview of the TGE

The Issuer will undertake a TGE to sell circa 840,000,000 CENNZ main tokens to qualifying wholesale purchasers. This number represents 70% of the total supply of CENNZ tokens of circa 1.2 billion.

To purchase CENNZ tokens in the TGE, an applicant must enter into a subscription agreement and meet the eligibility criteria which includes KYC/AML compliance.

The TGE will commence on 15 January 2018 and end on 15 February 2018, subject to any variation or extension granted by the Issuer in its sole and absolute discretion.

The proceeds of the TGE will be used to finance the ongoing development and maintenance of the Centrality Platform and associated services. The timing and volumes of CENNZ tokens sold in the TGE during the TGE period will be determined by the Issuer in view of prevailing market dynamics. At the conclusion of the TGE, the 840,000,000 distributed CENNZ will constitute the entirety of the available liquid supply post lockdown date.

The aim of the TGE is to raise the equivalent of USD $100 million for application in accordance with the following forecast schedule:

CENNZ Token Allocations in the TGE

In addition to the CENNZ tokens issued to wholesale purchasers, described in this section of this White Paper, a further approximately 240 million CENNZ will be issued to Centrality Investments as consideration for the arrangement with Centrality Platform Pte. Limited in respect of the intellectual property comprised in the Centrality Platform made on an arm's length basis. Centrality Investments will not be able to sell or otherwise deal with its CENNZ tokens until after the second anniversary date of the Release Date.

An additional circa 60 million CENNZ has been allocated to developers to ensure that they have a personal incentive to grow the platform moving forward.

The remaining circa 60 million CENNZ will be retained by the Issuer (Centrality Platform Pte. Limited) and released slowly to fund growth of the Centrality ecosystem strategically by supporting the following four broad purposes:

1. Operational costs, infrastructure, developers

2. Sourcing and funding revolutionary start-ups and participants that will enhance the Centrality Platform and ecosystem for all participants. (Note that holders of CENNZ tokens will not have any ownership stake in the businesses acquired.)

3. Supporting and growing the Blockchain and Centrality developer community

4. Marketing and PR for the Centrality platform

Lock-down on CENNZ trading post-issue

There will be a minimum 6 week lockdown where CENNZ holders cannot trade CENNZ tokens post issue.

Centrality Investments Limited and the platform developers that receive allocations described in Implementation and ERC20 Section will be subject to a 24 month lockdown period.

Following the lockdown period, Centrality Platform Pte. Limited will limit its supply of CENNZ to the market at a set rate e.g. 6,000,000 CENNZ or 10% of the total supply per month.

Buy Centrality with Credit Card or Debit Card

No matter what people say, it's easy to buy Centrality with a credit card.

Your first step will always be buying Bitcoins or Ethereum with your credit card. They can then be converted to Centrality.

Follow these steps:

Buy Bitcoin or Etherium at an exchange you like.

Transfer Bitcoin or Etherium to an exchange that supports Centrality currency.

Finally, exchange Bitcoin or Etherium to Centrality.

Please follow our step by step guide bellow to buy Centrality.

1. Create an Account on Coinbase

To buy Ethereum from Coinbase – which you will exchange for Centrality (CENNZ) later – you have to create an account at Coinbase. Click this link here to create an account.

Click 'sign up' button and fill out the form. Enter your name (it has to be exactly the same as it's written on your photo ID), email, password and location.

Coinbase is regulated by the US government and follows strict financial rules. As such, they have to verify your identity. It takes some time and effort, however, this makes Coinbase the reputation of the must trustworthy way to convert regular currency into cryptocurrency.

Verify The Coinbase Account

Since Coinbase needs to verify your account, you have to give them your phone number, upload an image of your photo ID and verify your card (credit or debit) or back account. Only then will you be able to buy cryptocurency.

If you use a card on Coinbase, your fees will be higher, but your purchases will be instant. It is cheaper to use bank transfers, but it is slow – it can take up to a week to get your coins.

When your payment details are verified, click 'buy/sell' button on the top menu.

Select 'Ethereum', and enter how much money you want to spend/how many coins you want to buy in the windows on the bottom of the page.

Once you have done that, click the 'Buy' button.

You will now have to confirm you purchase.

Do this by pressing the 'Confirm Buy' button.

You now own some Ethereum. However, don't close Coinbase yet – we're going to use it later!

2. Open An Account In An Exchamge That Accepts Centrality (CENNZ)

Now that you have some Ethereum, you to find a place to exchanged it for CENNZ.

Here is a list of online exchanges where CENNZ is traded:

This coin is not available in any exchange as we know.

Exchanges are listed in the descending order of trade volume (that is, how much trading happens on those sides).

3. Transfer Ethereum from Coinbase to Exchange

After you have opened an account at one of the exchanges from the above list, you should find your ETH wallet address.

The details of finding the address can be different depending on the website, but it's usually easy and simple.

Make sure that you get your "deposit" or "receiver" address.

Copy/write down your ETH wallet address for the next step. (The adress (Your own unique address of course, not the address above!)

4. Transfer Ethereum To Your New Wallet

Transfer Ethereum from your Coinbase account or any other account/wallet where you keep your ETH to the receiver/deposite ETH address from the step #3.

5. Exchange Ethereum for CENNZ

When Ethereum appear in your new exchange account (it may take a few minutes), you are read to trade it for CENNZ in the new the exchange.

The process of trading depend on the exchange, but it's largely similar across the platforms.

Generally, you will want to find the CENNZ/ETH trading pair and "place an order" to buy CENNZ with your ETH funds.

The order can work immediately – any delay is usually because the exchange is trying to find enough "sell" orders to fulfill your "buy" order.

Congratulations! You are now the proud owner of some amount of CENNZ!

The cheapest way to do it is to buy bitcoins with bank account (or Centrality directly with bank account) and exchange the BTC for Centrality.

The fastest way is to buy Centrality with a credit card, but you will be charged higher fees.

What Is Centrality Mining?

You cannot mine Centrality as it has a different network structure than Bitcoin. You can only purchase Centrality from an exchange.

Latest Centrality News

Rewarding CENNZ token holders

Centrality to airdrop SNGX tokens to CENNZ token holders.

SingularX.com launched in November, 2017. A joint venture between SingularDTV and Centrality, SingularX is a decentralised exchange for tokens generated in the SingularDTV/Centrality meta-verse, as well as all Ethereum-based tokens that have utility and serve a purpose.

SingularX fees are 0.3% per transaction. These fees are pushed into the SNGX token for storage or to be withdrawn by their holder. 10,000,000 SNGX tokens exist, split evenly between SingularDTV and Centrality. Centrality will airdrop its 5,000,000 SNGX into the CENNZ token in the coming weeks.

A snapshot of all CENNZ addresses will occur in May. The exact date and time of this snapshot is to be announced. In order to receive your SNGX tokens, move your CENNZ off all exchanges and into designated wallets before this snapshot occurs.

Our vision for SingularX is for it to become a crypto-community owned Dapplication — open-sourced and with all SNGX tokens given away to SNGLS and CENNZ holders. All transaction fees are stored in the SNGX reward contract in the form of ETH and tokens. Currently, SingularX is paying for itself from its transaction fees, for a decentralized exchange in beta that has yet to be marketed, that's a positive achievement.

{% include page-toc.html %}

We're hoping that SNGX holders will use SingularX as their preferred exchange and spread the word to others. Emergent behaviour of a community-owned exchange remains to be seen, but we hope this experiment will be fruitful, and give something back to CENNZ token holders. SNGX and ETH bonuses will also be awarded on a monthly basis to the top 5 most active traders on SingularX.

A portion of SNGX tokens earmarked for the airdrop may be held back to provide for these bonuses. Additional details on this bonus-reward will be forthcoming. Remember, anyone receiving any store of value from the SNGX token must be responsible for their own tax liability in their respective jurisdictions.

SNGX => CENNZ

5,000,000 SNGX into 1,200,000,000 CENNZ = 0.00416 SNGX into 1 CENNZ

Therefore, if you have 10,000 CENNZ, you will receive 41.6 SNGX.

Once the SNGX token is airdropped, then what? How do you see your SNGX tokens in your wallet and how do you withdraw ETH stored in the SNGX token?

1. Go to tokit.io and generate a wallet if you haven't already.

2. You'll need to see the SNGX token in your wallet, so import its token address, 0x78774d1c3277b83459c730921bff11019017b233. Remember, never send any tokens to this address, you'll lose them forever. This address should only be used once to import the SNGX token address into your wallet.

3. Click into your SNGX wallet card and at the bottom left your pro rata portion of your SNGX ETH will be shown.

You may also notice the "deposit" button. This allows you to deposit ETH into the SNGX Reward contract. As the creators of SNGX, this is a process Centrality can do on a daily basis with a push of a button, to push the transaction fees into SNGX.

For the record, there will be no ETH appreciation rewards pushed into the CENNZ token. All ETH raised in the CENNZ TGE in January this year will be used to develop the Centrality ecosystem. Any and all revenue generated by Centrality will be pushed into the CENNZ token once the appropriate and regulated infrastructure is established. There is currently no timing on when this infrastructure will be established. More updates on that will come later.

Centrality reserves the right to change the above-mentioned specifics for the benefit of the Centrality ecosystem.


text:
package com.springml.marketo.rest.client;

import com.springml.marketo.rest.client.model.QueryResult;
import org.apache.commons.io.IOUtils;
import org.junit.Before;
import org.junit.Test;

import java.util.*;

import static com.springml.marketo.rest.client.util.MarketoClientConstants.*;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;

/**
 * Created by sam on 29/12/16.
 */

public class LeadDatabaseClientTest extends BaseDatabaseClientTest {

    private String response;
    private String emptyResponse;

    @Before
    public void setUp() throws Exception {
        super.setUp();

        Map<String, String> params = getParamsMap("10");

        ClassLoader classLoader = getClass().getClassLoader();
        response = IOUtils.toString(classLoader.getResourceAsStream("leadResponse.json"), "UTF-8");
        emptyResponse = IOUtils.toString(classLoader.getResourceAsStream("leadEmptyResponse.json"),
                "UTF-8");

        when(httpHelper.get(MARKETO_BASEURI, "/rest/v1/leads.json", "e4ceb18c-f578-4ecb:sj", params)).
                thenReturn(response);
    }

    @Test
    public void testQueryLeads() throws Exception {

        Map<String, String> params = new HashMap<>(8);
        params.put(STR_FILTER_TYPE, "Id");
        params.put(STR_FILTER_VALUES, "10");

        when(httpHelper.get(MARKETO_BASEURI, "/rest/v1/leads.json", "e4ceb18c-f578-4ecb:sj", params)).
                thenReturn(response);

        List<Map<String, String>> expectedResults = getExpectedResultMaps();

        QueryResult actualQueryResult = leadDatabaseClient.query("leads", "Id", "10");
        assertEquals(expectedResults, actualQueryResult.getResult());
    }

    @Test
    public void testQueryLeadsWithFields() throws Exception {

        QueryResult actualQueryResult = leadDatabaseClient.query("leads", "Id", "10",
                Collections.singletonList("email"));

        List<Map<String, String>> expectedResults = getExpectedResultMaps();
        assertEquals(expectedResults, actualQueryResult.getResult());
    }

    @Test
    public void testQueryLeadsForAllRecords() throws Exception {
        when(httpHelper.get(eq(MARKETO_BASEURI), eq("/rest/v1/leads.json"), eq("e4ceb18c-f578-4ecb:sj"), any(Map.class))).
                thenReturn(response).thenReturn(emptyResponse);

        List<Map<String, String>> actualQueryResults = leadDatabaseClient.getAllRecords("leads");
        List<Map<String, String>> expectedResults = getExpectedResultMaps();
        assertEquals(expectedResults, actualQueryResults);
    }

    @Test
    public void testQueryLeadsForAllRecordsWithFields() throws Exception {
        when(httpHelper.get(eq(MARKETO_BASEURI), eq("/rest/v1/leads.json"), eq("e4ceb18c-f578-4ecb:sj"), any(Map.class))).
                thenReturn(response).thenReturn(emptyResponse);

        List<Map<String, String>> actualQueryResults = leadDatabaseClient.getAllRecords("leads", Arrays.asList("email"));
        List<Map<String, String>> expectedResults = getExpectedResultMaps();

        assertEquals(expectedResults, actualQueryResults);
    }

    @Test
    public void testFetchResultsForLeads() throws Exception {

        Map<String, String> params = getParamsMap("1,2");
        ClassLoader classLoader = getClass().getClassLoader();
        response = IOUtils.toString(classLoader.getResourceAsStream("leadFetchPageResponse.json"),
                "UTF-8");
        when(httpHelper.get(MARKETO_BASEURI, "/rest/v1/leads.json", "e4ceb18c-f578-4ecb:sj", params)).
                thenReturn(response);

        QueryResult actualQueryResult = leadDatabaseClient.query("leads", "Id", "1,2",
                Arrays.asList("email"));

        QueryResult queryResult = getQueryResult(actualQueryResult);
        Map<String, String> pageTokenParams = getParamsMap("1,2");
        pageTokenParams.put(STR_NEXT_PAGE_TOKEN, PAGING_TOKEN);
        response = IOUtils.toString(classLoader.getResourceAsStream("leadFetchPageResponse.json"),
                "UTF-8");
        when(httpHelper.get(MARKETO_BASEURI, "/rest/v1/leads.json", "e4ceb18c-f578-4ecb:sj",
                pageTokenParams)).thenReturn(response);

        QueryResult fetchQueryResult = leadDatabaseClient.fetchNextPage(queryResult);
        List<Map<String, String>> results = getMapsForFetchResult();
        assertEquals(results, fetchQueryResult.getResult());
    }

    private QueryResult getQueryResult(QueryResult actualQueryResult) {
        QueryResult queryResult = new QueryResult();
        queryResult.setObject(actualQueryResult.getObject());
        queryResult.setFilterType(actualQueryResult.getFilterType());
        queryResult.setFilterValues(actualQueryResult.getFilterValues());
        queryResult.setFields(actualQueryResult.getFields());
        queryResult.setNextPageToken(actualQueryResult.getNextPageToken());
        return queryResult;
    }

    private List<Map<String, String>> getMapsForFetchResult() {
        Map<String, String> result1 = new HashMap<>();
        result1.put("id", "1");
        result1.put("updatedAt", "2016-12-27T06:02:18Z");
        result1.put("lastName", "Alex");
        result1.put("email", "sam@test.com");
        result1.put("createdAt", "2016-12-27T06:02:18Z");
        result1.put("firstName", "Sam");

        Map<String, String> result2 = new HashMap<>();
        result2.put("id", "2");
        result2.put("updatedAt", "2016-12-30T05:25:29Z");
        result2.put("lastName", "Wright");
        result2.put("email", "rwrighty@csmonitor.com");
        result2.put("createdAt", "2016-12-30T05:25:29Z");
        result2.put("firstName", "Robin");

        List<Map<String, String>> results = new ArrayList<>();
        results.add(result1);
        results.add(result2);
        return results;
    }

    private List<Map<String, String>> getExpectedResultMaps() {
        Map<String, String> result = new HashMap<>();

        result.put("id", "10");
        result.put("updatedAt", "2016-12-27T06:02:18Z");
        result.put("lastName", "Alex");
        result.put("email", "sam@test.com");
        result.put("createdAt", "2016-12-27T06:02:18Z");
        result.put("firstName", "Sam");

        return Arrays.asList(result);
    }

    private Map<String, String> getParamsMap(String value) {
        Map<String, String> params = new HashMap<>(8);
        params.put(STR_FILTER_TYPE, "Id");
        params.put(STR_FILTER_VALUES, value);
        params.put(STR_FIELDS, "email");
        return params;
    }
}

redpajama_set_name: RedPajamaGithub


text:
/**
 * RSocket.h
 * Sockets simple wrapper.
 * Author Kucheruavyu Ilya (kojiba@ro.ru)
 * 12/19/14 2014 Ukraine Kharkiv
 *  _         _ _ _
 * | |       (_|_) |
 * | | _____  _ _| |__   __ _
 * | |/ / _ \| | | '_ \ / _` |
 * |   < (_) | | | |_) | (_| |
 * |_|\_\___/| |_|_.__/ \__,_|
 *          _/ |
 *         |__/
 **/

#ifndef __R_SOCKET_H__
#define __R_SOCKET_H__

#include "RByteOperations.h"

#ifndef __WIN32
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>

    typedef int SocketDescriptor;
    #define endSockets()
#else
    #include <winsock2.h>
    #include <ws2tcpip.h>

    typedef SOCKET SocketDescriptor;
    #define endSockets() WSACleanup();
#endif

extern const byte networkConnectionClosedConst;
extern const byte networkOperationErrorConst;
extern const byte networkOperationSuccessConst;

typedef struct sockaddr_in SocketAddressIn;
typedef struct sockaddr    SocketAddress;
typedef struct ip_mreq     MulticastAddress;

extern const
char* addressToString(SocketAddressIn *address);

class(RSocket)
        SocketDescriptor socket;

        uint16_t         port;
        SocketAddressIn  address;
        socklen_t        addressLength;
        size_t           packetCounter;

endOf(RSocket)

RSocket * makeRSocket(RSocket *object, int socketType, int protocolType);
extern
constructor (RSocket));
destructor  (RSocket);
printer     (RSocket);

// Setters
method(rbool, bindPort,           RSocket),    uint16_t port); // for receiver
method(void,  setPort,            RSocket),    uint16_t port); // for sender

method(rbool, enableBroadCast,    RSocket),    rbool enable);

method(rbool, joinMulticastGroup, RSocket),    const char * const address);
method(void,  setAddress,         RSocket),    const char * const address);
method(void,  reuseAddress,       RSocket));

method(RSocket *,  accept,        RSocket));

// Main methods
method(byte,  send,               RSocket),    const pointer buffer, size_t size);  // sends to receiver size bytes
method(ssize_t,  receive,            RSocket),    pointer buffer, size_t size);  // buffer must be pre allocated at least 1500 bytes, return 255 if fails, 1 if received some

#endif /*__R_SOCKET_H__*/


text:
using Microsoft.Build.Evaluation;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.MSBuild;
using RS.JSProxyGenerator;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace RS.JSProxyGeneratorTester
{
    class Program
    {
        static void Main(string[] args)
        {
            //templatecreator test

            Microsoft.Build.Evaluation.Project project =
                    new Microsoft.Build.Evaluation.Project(@"C:\\Projects\\HRP\\develop\\RS.Sal\\RS.Sal.Web\\RS.Sal.Web.csproj");

            var msWorkspace = MSBuildWorkspace.Create();

            var solution = msWorkspace.OpenSolutionAsync(@"C:\\Projects\\HRP\\develop\\RS.Sal\\RS.Sal.sln").Result;

            SolutionTypesManager.Classes = new List<ClassDeclarationSyntax>();
            SolutionTypesManager.Interfaces = new List<InterfaceDeclarationSyntax>();

            foreach (var proj in solution.Projects)
            {
                Microsoft.Build.Evaluation.Project proiect;
                if (proj.FilePath == project.FullPath)
                    proiect = project;
                else
                    proiect = new Microsoft.Build.Evaluation.Project(proj.FilePath);

                var items = proiect.Items.Where(it => it.EvaluatedInclude.EndsWith(".cs"));
                foreach (var item in items)
                {
                    string filepath = Path.Combine(proiect.DirectoryPath, item.EvaluatedInclude);
                    string code = File.ReadAllText(filepath);
                    SyntaxTree tree = CSharpSyntaxTree.ParseText(code);
                    var root = (CompilationUnitSyntax)tree.GetRoot();

                    var classes = root.DescendantNodes().OfType<ClassDeclarationSyntax>().ToList();

                    if (classes.Count > 0)
                    {
                        Console.WriteLine("Found " + classes.Count + " class(es) in " + item.EvaluatedInclude
                            +" from project "+ Path.GetFileNameWithoutExtension( proiect.FullPath));
                        SolutionTypesManager.AddClasses(classes);
                    }
                    var interfaces = root.DescendantNodes().OfType<InterfaceDeclarationSyntax>().ToList();

                    if (interfaces.Count > 0)
                    {
                        Console.WriteLine("Found " + interfaces.Count + " interface(s) in " + item.EvaluatedInclude
                            + " from project " + Path.GetFileNameWithoutExtension(proiect.FullPath));
                        SolutionTypesManager.AddInterfaces(interfaces);
                    }
                }
            }

            ;
            List<EndPointClass> endpoints = null;

            EndPointClassesIdentifier endpointidentifier = new EndPointClassesIdentifier();
            List<EndPointClass> ControllerEndpoints = endpointidentifier.GetEndpoints(project);

            if (ControllerEndpoints != null)
                endpoints = ControllerEndpoints;

            List<EndPointClass> WCFEndpoints = endpointidentifier.GetWCFEndpoints();
            ;
            if (endpoints == null)
                endpoints = WCFEndpoints;
            else if (WCFEndpoints != null)
                endpoints = (endpoints.Concat(WCFEndpoints)).ToList();

            if (endpoints == null || endpoints.Count == 0)
            {
                Console.WriteLine(" doesn't contain endpoints.");
                Console.ReadKey();
                return;
            }

            foreach (var endp in endpoints)
            {
                Console.WriteLine(endp.Name + " found :");
                foreach (var wa in endp.WebActions)
                {
                    Console.Write("\t" + wa.Name + "(");

                    foreach (var param in wa.Parameters)
                        Console.Write(param.Name + " ");

                    Console.WriteLine(")");
                }
            }

            //generate string
            //TemplateCreator tc = new TemplateCreator(endpoints);
            //Console.WriteLine(tc.newProxy);

            Console.ReadKey();
            //DLLHandler.UnloadDLLs();
        }
    }
}


text:
require 'rexml/document'
require File.dirname(__FILE__) + '/../../../spec_helper'

describe "REXML::Element#texts" do

  it "returns an array of the Text children" do
    e = REXML::Element.new("root")
    e.add_text "First"
    e.add_text "Second"
    e.texts.should == ["FirstSecond"]
  end

  it "returns an empty array if it has no Text children" do
    REXML::Element.new("root").texts.should == []
  end
end


text:
/**
 * Populate DB with sample data on server start
 * to disable, edit config/environment/index.js, and set `seedDB: false`
 */

'use strict';
import sqldb from '../sqldb';
var Thing = sqldb.Thing;
var User = sqldb.User;

Thing.sync()
  .then(() => {
    return Thing.destroy({ where: {} });
  })
  .then(() => {
    Thing.bulkCreate([{
      name: 'Development Tools',
      info: 'Integration with popular tools such as Webpack, Gulp, Babel, TypeScript, Karma, '
            + 'Mocha, ESLint, Node Inspector, Livereload, Protractor, Pug, '
            + 'Stylus, Sass, and Less.'
    }, {
      name: 'Server and Client integration',
      info: 'Built with a powerful and fun stack: MongoDB, Express, '
            + 'AngularJS, and Node.'
    }, {
      name: 'Smart Build System',
      info: 'Build system ignores `spec` files, allowing you to keep '
            + 'tests alongside code. Automatic injection of scripts and '
            + 'styles into your index.html'
    }, {
      name: 'Modular Structure',
      info: 'Best practice client and server structures allow for more '
            + 'code reusability and maximum scalability'
    }, {
      name: 'Optimized Build',
      info: 'Build process packs up your templates as a single JavaScript '
            + 'payload, minifies your scripts/css/images, and rewrites asset '
            + 'names for caching.'
    }, {
      name: 'Deployment Ready',
      info: 'Easily deploy your app to Heroku or Openshift with the heroku '
            + 'and openshift subgenerators'
    }]);
  });

User.sync()
  .then(() => User.destroy({ where: {} }))
  .then(() => {
    User.bulkCreate([{
      provider: 'local',
      name: 'Test User',
      email: 'test@example.com',
      password: 'test'
    }, {
      provider: 'local',
      role: 'admin',
      name: 'Admin',
      email: 'admin@example.com',
      password: 'admin'
    }])
    .then(() => {
      console.log('finished populating users');
    });
  });


text:
using Checkout.ApiServices.SharedModels;
using System.Collections.Generic;
namespace Checkout.ApiServices.Charges.RequestModels
{
    public class DefaultCardCharge : BaseCharge
    {
        public string TransactionIndicator { get; set; }
    }
}


text:
Nanoc Fuel
==========

[![Build Status](https://secure.travis-ci.org/kamui/nanoc-fuel.png)](http://travis-ci.org/kamui/nanoc-fuel)

Nanoc Fuel is a [nanoc](http://nanoc.stoneship.org/) gem that adds helpers for Facebook (like init, button, comments) and Google (analytics).

Installation
------------

- You need Nanoc 3.2 or above, works with Nanoc 3.3
- This gem requires haml 3.1 or above

If you're using bundler, just add this to your Gemfile:

```ruby
gem 'nanoc-fuel'
```

Otherwise, you can just install the gem manually:

```ruby
gem install nanoc-fuel
```

and then in your nanoc project, put this in lib/default.rb:

```ruby
require 'nanoc-fuel/tasks'
```

Usage
-----

For the Facebook/Google helpers:

In your nanoc project's `lib/helpers.rb` file, include one of the helpers:

```ruby
include NanocFuel::Helpers::Facebook
include NanocFuel::Helpers::Google
```

Then, in your layout add any of these:

```ruby
fb_init("FB APP ID HERE")

fb_comments("url", "num_posts", "width")

fb_like_btn("standard", "450", "true", "true")

ga_tracking("UA-XXXXX")
```

Contact
-------
You can reach me at <jack@jackchu.com>.


text:
Run this project as a Spring Boot app (e.g. import into IDE and run
main method, or use "mvn spring-boot:run or gradle bootRun or ./gradlew bootRun"). It will start up on port
8761 and serve the Eureka API from "/eureka".

## Resources

| Path             | Description  |
|------------------|--------------|
| /                        | Home page (HTML UI) listing service registrations          |
| /eureka/apps         | Raw registration metadata |

## Docker Container

There is a Maven goal (using a [plugin](https://github.com/spring-cloud-samples/eureka/blob/feature/docker/pom.xml#L48)) to
generate the Docker container. The container is published in dockerhub at `springcloud/eureka`.


text:
require "bandcamp/request"
require "bandcamp/getter"
require "bandcamp/track"
require "bandcamp/configuration"
require "bandcamp/version"

module Bandcamp

  def self.config
    @configuration ||= Configuration.new
  end

  def self.get
    request
  end

  def self.search band_name
    request.search(band_name)
  end

  def self.resolve
    request
  end

  private

  def self.request
    Getter.new(Request.new config.api_key)
  end

end


text:
using System;
using System.Collections.Generic;
using JetBrains.Annotations;
using RiceDoctor.Shared;
using static RiceDoctor.OntologyManager.GetType;

namespace RiceDoctor.OntologyManager
{
    public class Attribute : Entity<Attribute>, IAnalyzable
    {
        [CanBeNull] private IReadOnlyCollection<Class> _allDomains;
        private bool _canGetAllDomains;
        private bool _canGetComment;
        private bool _canGetDirectDomains;
        [CanBeNull] private string _comment;
        [CanBeNull] private IReadOnlyCollection<Class> _directDomains;

        public Attribute(
            [NotNull] string id,
            [CanBeNull] string label = null,
            [CanBeNull] string comment = null,
            [CanBeNull] DataType? range = null,
            [CanBeNull] IReadOnlyList<string> enumeratedValues = null)
            : base(id, label)
        {
            if (comment != null)
            {
                _comment = comment;
                _canGetComment = false;
            }

            Range = range;
            if (Range == DataType.Enumerated)
            {
                Check.NotEmpty(enumeratedValues, nameof(enumeratedValues));
                EnumeratedValues = enumeratedValues;
            }
        }

        public DataType? Range { get; }

        [CanBeNull]
        public IReadOnlyList<string> EnumeratedValues { get; }

        public override EntityType Type => EntityType.Attribute;

        public bool IsDocumentAnalyzable => false;

        public bool IsOntologyAnalyzable => true;

        [CanBeNull]
        public string GetComment()
        {
            if (_canGetComment) return _comment;

            _comment = Manager.Instance.GetComment(Id);
            _canGetComment = true;

            return _comment;
        }

        [CanBeNull]
        public IReadOnlyCollection<Class> GetDirectDomains()
        {
            if (_canGetDirectDomains) return _directDomains;

            _directDomains = Manager.Instance.GetAttributeDomains(Id, GetDirect);
            _canGetDirectDomains = true;

            return _directDomains;
        }

        public void SetDirectDomains([CanBeNull] IReadOnlyCollection<Class> directDomains)
        {
            if (_canGetDirectDomains)
                throw new InvalidOperationException(CoreStrings.CannotSetAgain(nameof(SetDirectDomains)));

            _directDomains = directDomains;
            _canGetDirectDomains = true;
        }

        [CanBeNull]
        public IReadOnlyCollection<Class> GetAllDomains()
        {
            if (_canGetAllDomains) return _allDomains;

            _allDomains = Manager.Instance.GetAttributeDomains(Id, GetAll);
            _canGetAllDomains = true;

            return _allDomains;
        }

        public void SetAllDomains([CanBeNull] IReadOnlyCollection<Class> allDomains)
        {
            if (_canGetAllDomains)
                throw new InvalidOperationException(CoreStrings.CannotSetAgain(nameof(SetAllDomains)));

            _allDomains = allDomains;
            _canGetAllDomains = true;
        }
    }
}


text:
namespace ash {

class DisplayInfo;
struct DisplayMode;

// An object that observes changes in display configuration and
// update DisplayManagers.
class DisplayChangeObserver : public ui::DisplayConfigurator::StateController,
                              public ui::DisplayConfigurator::Observer,
                              public ui::InputDeviceEventObserver,
                              public ShellObserver {
 public:
  // Returns the mode list for internal display.
  ASH_EXPORT static std::vector<DisplayMode> GetInternalDisplayModeList(
      const DisplayInfo& display_info,
      const ui::DisplayConfigurator::DisplayState& output);

  // Returns the resolution list.
  ASH_EXPORT static std::vector<DisplayMode> GetExternalDisplayModeList(
      const ui::DisplayConfigurator::DisplayState& output);

  DisplayChangeObserver();
  ~DisplayChangeObserver() override;

  // ui::DisplayConfigurator::StateController overrides:
  ui::MultipleDisplayState GetStateForDisplayIds(
      const std::vector<int64>& outputs) const override;
  bool GetResolutionForDisplayId(int64 display_id,
                                 gfx::Size* size) const override;

  // Overriden from ui::DisplayConfigurator::Observer:
  void OnDisplayModeChanged(
      const ui::DisplayConfigurator::DisplayStateList& outputs) override;

  // Overriden from ui::InputDeviceEventObserver:
  void OnTouchscreenDeviceConfigurationChanged() override;
  void OnKeyboardDeviceConfigurationChanged() override;
  void OnMouseDeviceConfigurationChanged() override;
  void OnTouchpadDeviceConfigurationChanged() override;

  // Overriden from ShellObserver:
  void OnAppTerminating() override;

  // Exposed for testing.
  ASH_EXPORT static float FindDeviceScaleFactor(float dpi);

 private:
  DISALLOW_COPY_AND_ASSIGN(DisplayChangeObserver);
};

}  // namespace ash

#endif  // ASH_DISPLAY_DISPLAY_CHANGE_OBSERVER_CHROMEOS_H_


text:
import os
from setuptools import setup

PACKAGE = "allure-behave"
VERSION = "2.2.3b1"

classifiers = [
    'Development Status :: 4 - Beta',
    'Intended Audience :: Developers',
    'License :: OSI Approved :: Apache Software License',
    'Topic :: Software Development :: Quality Assurance',
    'Topic :: Software Development :: Testing'
]

install_requires = [
    "behave>=1.2.5",
    "allure-python-commons==2.2.3b1"
]

def read(fname):
    return open(os.path.join(os.path.dirname(__file__), fname)).read()

def main():
    setup(
        name=PACKAGE,
        version=VERSION,
        description="Allure behave integration",
        url="https://github.com/allure-framework/allure-python",
        author="QAMetaSoftware, Stanislav Seliverstov",
        author_email="sseliverstov@qameta.io",
        license="Apache-2.0",
        classifiers=classifiers,
        keywords="allure reporting behave",
        long_description=read('README.rst'),
        packages=["allure_behave"],
        package_dir={"allure_behave": "src"},
        install_requires=install_requires
    )

if __name__ == '__main__':
    main()


text:
// Copyright 2011 The Whiley Project Developers
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package wyal.lang;

import wyal.lang.WyalFile.Type;

/**
 *

 * A domain represents a universe of values over which an assertion can be
 * tested for validity. The most obvious example of this would be the
 * concrete domain, which represents real concrete values and, hence, we
 * can simply execute an assertion to set whether it evaluates to
 * true, false or is undefined. The intention,
 * however, is that more complex abstract domains are possible allows us, for
 * example, to symbolically execute an assertion.
 *

 *
 * @author David J. Pearce
 *
 */
public interface Domain {
	/**
	 * Construct an iterator that will walk over all known values for a
	 * given type.
	 *
	 * @param type
	 * @return
	 */
	Domain.Generator generator(Type type);

	public interface Generator {
		/**
		 * Determine whether there is another element in this domain.
		 *
		 * @return
		 */
		public boolean hasNext();

		/**
		 * Get the current value of this generator
		 *
		 * @return
		 */
		public Object get();

		/**
		 * Move this generator to its next value
		 */
		public void next();

		/**
		 * Reset this generator back to the beginning
		 */
		public void reset();
	}

	/**
	 * Represents an abstract value within the given domain.
	 *
	 * @author David J. Pearce
	 *
	 */
	public interface Value {
		/**
		 * Determine whether or not two abstract values are equal.
		 *
		 * @param value
		 * @return
		 */
		public Value.Boolean equal(Value value);

		/**
		 * Check whether a given abstract value is an instance of a give type or
		 * not.
		 *
		 * @param type
		 * @return
		 */
		public Value.Boolean isInstance(Type type);

		/**
		 * Represents an abstract null value.
		 *
		 * @author David J. Pearce
		 *
		 */
		public interface Null {

		}

		/**
		 * Represents an abstract bool value which has only two
		 * concrete instantiations (true and false).
		 *
		 * @author David J. Pearce
		 *
		 */
		public interface Boolean {
			public Value.Boolean and(Value.Boolean b);

			public Value.Boolean or(Value.Boolean b);
		}

		/**
		 * Represents an abstract int value which has a potentially
		 * infinite number of integer values.
		 *
		 * @author David J. Pearce
		 *
		 */
		public interface Integer {
			public Value.Boolean lessThanOrEqual(Value.Integer other);

			public Value.Integer add(Value.Integer other);

			public Value.Integer subtract(Value.Integer other);

			public Value.Integer multiply(Value.Integer other);

			public Value.Integer divide(Value.Integer other);
		}

		/**
		 * Represents an abstract array value which has a
		 * potentially infinite number of array values.
		 *
		 * @author David J. Pearce
		 *
		 */
		public interface Array {
			public Value.Integer length();

			public Value getIndex(Value.Integer index);

			public Value.Array setIndex(Value.Integer index, Value value);
		}

		/**
		 * Represents an abstract record value which has a
		 * potentially infinite number of record values.
		 *
		 * @author David J. Pearce
		 *
		 */
		public interface Record {
			public Value getField(WyalFile.Identifier fieldName);

			public Value.Record setField(WyalFile.Identifier fieldName, Value value);
		}
	}
}


text:
import kivy
kivy.require('1.8.0')
from kivy.app import App
from Connect import *

__version__ = '1.0'

class ConnectApp(App):

	def build(self):

		return ConnectFourGrid(cols=7,rows=6)

if __name__ == '__main__':
	ConnectApp().run()


text:
<component name="InspectionProjectProfileManager">
  <profile version="1.0">
    <option name="myName" value="Project Default" />
    <inspection_tool class="AndroidLintDrawAllocation" enabled="true" level="ERROR" enabled_by_default="true" />
    <inspection_tool class="ClassMayBeInterface" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="FieldMayBeFinal" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="GroovyConstantNamingConvention" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="m_regex" value="[A-Z\d]*" />
      <option name="m_minLength" value="4" />
      <option name="m_maxLength" value="32" />
    </inspection_tool>
    <inspection_tool class="GroovyStaticVariableNamingConvention" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="m_regex" value="s_[a-z][A-Za-z\d]*" />
      <option name="m_minLength" value="4" />
      <option name="m_maxLength" value="32" />
    </inspection_tool>
    <inspection_tool class="GroovyVariableCanBeFinal" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="LocalCanBeFinal" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="REPORT_VARIABLES" value="true" />
      <option name="REPORT_PARAMETERS" value="true" />
    </inspection_tool>
    <inspection_tool class="LoggerInitializedWithForeignClass" enabled="false" level="WARNING" enabled_by_default="false">
      <option name="loggerClassName" value="org.apache.log4j.Logger,org.slf4j.LoggerFactory,org.apache.commons.logging.LogFactory,java.util.logging.Logger" />
      <option name="loggerFactoryMethodName" value="getLogger,getLogger,getLog,getLogger" />
    </inspection_tool>
    <inspection_tool class="MisorderedAssertEqualsParameters" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="MissortedModifiers" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="m_requireAnnotationsFirst" value="true" />
    </inspection_tool>
  </profile>
</component>


text:
/**
 * Constructor for a group timeline
 */
StatusNet.TimelineViewGroup = function(client) {
    StatusNet.TimelineView.call(this, client);
    this.title = "The {name} group on {site}";
};

// Make StatusNet.TimelineViewGroup inherit TimelineView's prototype
StatusNet.TimelineViewGroup.prototype = heir(StatusNet.TimelineView.prototype);

/**
 * Show profile information header for this group
 */
StatusNet.TimelineViewGroup.prototype.showGroupInfo = function() {

    var timeline = this.client.getActiveTimeline();
    var group = timeline.group;

    StatusNet.debug("showGroupInfo()");

    $('#profile_info').remove();

    var html = [];

    html.push('
');
    html.push('');

    html.push('<div id="profile_action_links"');

    if (group.member === "false" && group.blocked !== "true") {
        html.push('Join');
    } else {
        html.push('Leave');
    }

    html.push('</div');

    html.push('
!' + group.username + '
');
    html.push('
');

    html.push('
Name
');
    html.push('
');
    if (group.fullname) {
        html.push(group.fullname);
    } else {
        html.push(group.username);
    }
    html.push('
');

    if (group.location) {
        html.push('
Location
');
        html.push('
' + group.location + '
');
    }

    if (group.homepage) {
        html.push('
Homepage
');
        html.push('
' + group.homepage + '
');
    }

    if (group.bio) {
        html.push('
Bio
');
        html.push('
' + group.bio + '
');
    }

    html.push('
');

    html.push('
');
    html.push('
Members
');
    html.push('
' + group.memberCount + '
');
    html.push('
')

    html.push('
');
    $('#header').append(html.join(''));
    StatusNet.debug("finished showing group info...");

    var that = this;

    $('a.group_join').bind('click', function(event) {
        that.client.joinGroup(group.id, this);
    });

    $('a.group_leave').bind('click', function(event) {
        that.client.leaveGroup(group.id, this);
    });
};

/**
 * Override the header to show name of the group associated with
 * this timeline
 */
StatusNet.TimelineViewGroup.prototype.showHeader = function () {

    StatusNet.debug("TimelineViewGroup.showHeader()");

    var timeline = this.client.getActiveTimeline();
    var groupName = timeline.group.username;

    StatusNet.debug("TimelineViewGroup.showHeader() - group = " + groupName);

    var title = this.title.replace("{name}", groupName)
                          .replace("{site}", this.client.account.getHost());

    StatusNet.debug("TimelineViewGroup.showHeader() - setting title to: " + title);

    $("#header").html("

");
    $("#header h1").text(title);

    this.showGroupInfo();
};


text:
    //function decleration
    function test() {
      // function code here!
    }

    // function expression
    var test2 = function() {
      // function code here!
    }

// Returning from a function

    function test() {
        return "I am returned from a function"
    }

    var returnedValue = test(); // "I am returned From a function"

// Supplying parameters to functions

    function test(parameter) {
        return parameter
    }

// function scope

    // cant use variables outisde of the the function when declared
    function test() {
        var name ="test"
        console.log(name) //test
    }

    console.log(name) //undefined;

    function test(name){
        console.log(name)
    }

    test("test") //test

    console.log(name) //undefined

    //Variables declared outside of the function can be used

    var fruit = "apple"

    function getFruit(){
        console.log(fruit) //"apple"
    }


text:
package com.twitter.finagle

import com.twitter.util.{Witness, Var}
import java.net.{InetSocketAddress, SocketAddress}
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.junit.JUnitRunner

@RunWith(classOf[JUnitRunner])
class NameTest extends FunSuite {
  test("Name.fromGroup") {
    val g = Group.mutable[SocketAddress]()
    val n = Name.fromGroup(g)

    var addr: Addr = Addr.Pending
    n.addr.changes.register(Witness({ addr = _ }))
    assert(addr == Addr.Pending)
    val set = Set[SocketAddress](new InetSocketAddress(0), new InetSocketAddress(1))
    g() = set

    val Addr.Bound(s2, r) = addr
    assert(s2.collect { case Address.Inet(ia, _) => ia } == set)
    assert(r.isEmpty)

    g() = Set(new SocketAddress {})
    val Addr.Failed(e) = addr
    assert(e.isInstanceOf[IllegalArgumentException])
  }

  test("Name.Bound maintains equality as per 'id'") {
    val id1, id2 = new {}
    val a1, a2 = Var(Addr.Pending)

    assert(Name.Bound(a1, id1) == Name.Bound(a2, id1))
    assert(Name.Bound(a1, id1) != Name.Bound(a1, id2))

    // It sucks that this is not symmetric, oh well.
    assert(Name.Bound(a1, id1) == id1)
    assert(Name.Bound(a1, id1) != id2)
  }

  test("Name.all maintains equality") {
    val names = Seq.fill(10) { Name.Bound.singleton(Var(Addr.Pending)) }.toSet

    assert(Name.all(names) == Name.all(names))
    assert(Name.all(names) != Name.all(names drop 1))
  }
}