[Please note that I'm a lightweight when it comes to just about any substance. Biochemically 'average' individuals will likely need higher doses to achieve the effects I describe below, but always start small!]
I had received 60 grams of dried Lion's Tail from an online vendor over a month back, which unfortunately contained mostly foliage and stems. My several experiments with smoking the foliage in a pipe were only somewhat successful, as the licorice and burnt-rubber flavor was unpleasantly strong, the smoke real thick and hot, and the only effects I perceived were mild sedation. However, sucking and chewing the leaves consistently got me a nice sedation without the respitory charring from the smoke, but again little else. Like a mild opiate, but nothing MJ-like that I could tell.
However, I was feeling adventurous over the last couple nights (a weekend), so I decided to try smoking the flowers. I was able to sift only ~20 of the red tubular blossoms (of various sizes) from the bag, but it was better than nothing :-P. I won't bother to estimate their weight.
My health and mindset at the time: Physically healthy with a positive outlook. College work was piling-up, but I didn't feel too stressed at the time. I hoped that the Lion's Tail would make the weekend nights really enjoyable (flowers smoked at night each time). Had consumed caffeine, ginseng, and small quantities (16 mg) of ephedrine much earlier the first day (but only caffeine-ginseng the second); stimulation had largely worn-off before I smoked.
Dosage: Approx. 3 good hits each night, which used up all the flower material. Each hit required 2-3 crumpled flowers, which burned to ash almost instantly (inhaled smoke while applying direct flame to material in pipe). Hits taken in ~1 minute intervals, for the most part.
The smell/flavor of the smoke was similar to that of the foliage, but thinner, milder, and sweeter. A taste I quickly acquired.
Effects (identical on each occasion): Initial effects came-on very rapidly during the first or second hit; similar to MJ's upswing. Lightheaded and lightbodied feeling (difficult for me to describe) followed by simulataneous relaxation and increase in energy, followed by a rapid mood-lift [basic MJ effects for me]. Some increased 'pressure' feeling on face, as reported by others, which disappeared in a short while. No unpleasant or 'toxic' feelings noticed. My mind seemed to remain clear and function normally (thoughts didn't race or slow down. crazy thoughts were lacking). Colors/lights brightened in intensity and refinement somewhat, as they do whenever I use a psychedelic. I was surprised at first and REALLY liked it.
After drinking alcohol while on LT, I felt unusually lucid and in-control, as with MJ. Significant quantities of booze did not put me into the dreamy trance it usually does along with MJ, however.
Now, some words on how the effects specifically differed from MJ. First, I did not experience the blatantly hallucinogenic visuals I get from a strong dose of MJ (seeing colors, mild surface-patterning hallucinations, CEVs, etc). Second, I experienced no increased anxiety or enhanced introversion; in fact, I became unusually confident and extroverted while in public with friends (restaurant and shooting pool). Third, the other senses did not seem to have been altered in any way. Fourth, lethargy was lacking. Fifth, no apparent alteration of short-term memory or impairment of attention-span in regards to external stimuli.
Overall, Lion's Tail blossoms granted me much of the ideal 'recreational' aspects of the MJ experience, while denying me the 'trippy' effects of MJ. I believe LT flowers provide the perfect high for all situations that would make a MJ-influenced person uncomfortable.
Duration: Uncertain. 3 hits worth provided at least a few hours of significant effects, but it was difficult to figure when it wore off completely. In any case, I was set for the night each time.
Blessed be anyone who finds a bounty of the flowers for sale. For now, I have a whole lot of foliage to boil...
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Serverless is the PaaS endgame
...but does not suit all workloads
Repo is the unit of collaboration
Repo commit is the unit of promotion
AWS Lambda is a viable execution platform
Responsibilities rather than Roles
Go is fantastic


Stratiform Precipitation
Curves show the daily stratiform precipitation by each model listed in the key for the "Upper Mississippi" domain (37N-47N; 89W-99W).
[Higgins = gridded observations; RSM/NP = NCEP RSM; RSM/Sc = Scripps RSM]


Usage
Icons are pictorial representations of objects. They help define the visual identity of SKY UX applications, and they provide a shorthand to visually convey meaning that users can understand at a glance. SKY UX uses glyphic, mono-color icons to facilitate, guide, and inform users.
Icons should not be used solely for decorative purposes.
How to select icons
To determine whether an icon is available for a new component, check the SKY UX icon dictionary below. Then make sure that your use case is consistent with how other components use the icon.
-
Do not use icons with established meanings for different purposes.
-
Be mindful of how icons are used in specific components such as grids, tiles, buttons, and modals.
Styling
Icons usually inherit their size and color from parent elements, particularly when you use them inline. If you use icons in a non-inline context and need a different size, Font Awesome provides size multiplier classes. Use the smallest size multiple that accomplishes your goals.
Dictionary
The icon dictionary provides a complete list of icons that we recommend for use in SKY UX. All the icons are from Font Awesome, and we support version 4.7.0. If Font Awesome does not have a particular icon, it is probably not common enough for its purpose to be immediately obvious to users.
When you use the SKY UX icon component to display Font Awesome icons, do not specify the fa fa- classes.


This webpage allows you analyse a sociogram. A sociogram consists of a group of items together positive and negative relationships between those items. The various tools provided for analysing a sociogram are:
The program produces a variety of types of graph. The main choice is what to include: you can include just the positive relationships, just the negatives, or both.
The chart consists of each item plotted at the position so that its x-coordinate is the number of (incoming) positive relationships and y-coordinate the number of (incoming) negative relationships.
If you specify group sizes, the program will attempt to fit the items into those groups.
There are two options that modify how the groups are constructed. When the option to allow disjointed groups is not checked then an item can be added to a group only when it has a positive relationship with an item already in there. When the option to ignore negatives is not checked then an item can only be added to a group if it doesn't have a negative relationship with an item already in there.
When a grouping is found, it is printed out. Each group within that grouping is analysed and the result of that analysis displayed after the group as a string of three characters that are zeros or ones. The first character answers the question "Does every item have an incoming positive relationship with another in that group?", the second is the same but for outgoing, the third is the same but for either incoming or outgoing. The full grouping is also scored, resulting in four numbers. The first counts the number of items with a positive relationship to another item in the same group, the second is the same but with a negative relationship. The third and fourth count the number of items with a positive, or negative, relationship from another item in the same group.
Items in the groups can also be preset by listing them in the textbox.
It can take a long time to go through all the possible groups. The dots indicate that the program is still working. The progress bar indicates the size of the current attempt at grouping: a full progress bar means that it has found a full grouping.
You can specify the data via a form, in a text box, or by uploading a file. You can download the data suitable for uploading again. You can also save the generated graphs or charts.
Note that no data is sent over the network. The processing of the data takes place in the browser on your machine. You can verify this by using this page with your computer detached from your network.
The graph generation code is done by this javascript port of Graphviz.


Flowers For The People Home Shop Place Order Browse Catalog Your Cart Services Daily Deliveries Botanical Designs Estate Services Corporate Services Weddings & Events Holiday Decor About Us About Us Contact Us Press Contact Us ###-###-####
Social Media Block
place holder for widget


All simulations were run for 100 model years and annual and seasonal averages were calculated for years 40–100 of the model output, with the exception of the NEP-Warm simulation, which was run for 60 model years with mean values calculated from years 40 to 60. Reported errors are calculated as the standard error of the mean multiplied by 1.96, which is the number of standard deviations required to contain 95% of the area of a normal distribution. The calculation of the standard error of the mean assumes a sample size of N independent samples, which in our case are the individual model years. Autocorrelation between model years, however, reduces the number of independent samples, as described by Santer et al. 54 This autocorrelation is corrected for by using Eq. (6) of Santer et al. 54 to determine an “effective sample size”, Ne, that adjusts the original sample size for this autocorrelation.
We calculate the global climate feedback parameter ( α) as F/Δ T, where F is the applied global radiative forcing (±1 W/m 2) and Δ T is the change in global average surface air temperature 55. The Arctic amplification factor is calculated as the ratio of the change in global surface air temperature to the change in Arctic surface air temperature (Δ Tglobal/Δ Tarctic) (Table 1). The cloud radiative forcing at the TOA is calculated as the difference in the net radiative flux between all-sky and clear-sky conditions. The greenhouse effect of clouds in the Arctic is calculated as the difference in the downwelling longwave radiation at the surface between all-sky and clear-sky conditions 56. We calculate the surface albedo forcing related to changes in sea-ice as the difference in upwelling shortwave radiation at the surface in clear-sky conditions. However, the enhanced absorption of shortwave radiation at the surface due to sea-ice retreat is in part compensated by enhanced shortwave reflection at the TOA due to changes in Arctic cloudiness. For example, the greater increase in Arctic cloud fraction in the NP-Warm contributes to an annual-mean negative cloud radiative effect at the top of the atmosphere (TOA) (−2.0 ± 0.36 and −1.7 ± 0.26 W/m 2 for the NP-Warm and NA-Warm simulations, respectively). However, this is composed of a positive cloud radiative effect from trapped longwave in winter—when the maximum Arctic warming occurs—and a negative cloud radiative effect from reflected shortwave in the summer, during which season the decreased albedo from sea-ice loss more than compensates for the increased cloud reflection. Thus, the warming effect of low clouds and sea-ice retreat together more than compensate for the reduction in incoming shortwave at the TOA due to enhanced cloud albedo.
The net change in shortwave radiation at the surface is interpreted as the effective shortwave absorption due to both cloud and sea-ice changes. Moisture convergence in the Arctic is defined as precipitation minus the surface water flux. Changes in Arctic sea-ice and cloud fraction are reported as the percent change in the area fraction relative to the control simulation. All calculations for the Arctic are defined as north of 66.6°.
The total northward atmospheric energy transport was calculated at each latitude, as well as its decomposition into dry static energy (i.e., sensible heat and geopotential energy terms) and moist (i.e., latent heat term) energy, following Yang et al. 57 As in Yang et al. 57, the total atmospheric energy transport through each latitude ( Ha(Φ)) is calculated as:
for Earth’s radius ( a), latitude increment (Φ′), top-of-atmosphere radiative flux ( RTOA), and surface radiative ( FS), with sign convention such that RTOA + FS constitutes energy into the atmosphere. The latent heat transport through each latitude ( HLH(Φ)) is similarly calculated using the moisture balance equation as
for latent heat of vaporization ( Lν). The dry static energy transport is calculated as the residual, HA(Φ) − HLH(Φ). Each term in the climatology as well as the perturbation in NP-Warm and NA-Warm cases is shown in Fig. 5a.
In order to diagnose where the latent energy is entering the Arctic in the NP-Warm and NA-Warm simulations, we analyzed the longitudinal distribution of latent energy transport across 66.6°N (Fig. 5b). We calculate this as the longitudinally resolved latent energy component of the vertically integrated moist static energy transport:
integrating between atmospheric pressure at the surface ( ps) and top-of-model ( pt) at latitude ( φ = 66.6 N), gravitational acceleration ( g) and other variables as in previous equations. The moisture transport (vq) is calculated using the model online diagnostic VQ, which outputs the multiplication of the two terms at each model time step and includes both the mean and the eddy components of the latent energy transport (Supplementary Figure 5). The direct Arctic heating from atmospheric energy convergence is calculated as the total atmospheric northward energy transport values divided by the area of the Arctic (2.089 × 10 13 m 2).


Overview
I wanted to design a feature that would allow users to seamlessly view, add, and delete payment options under their profile while also being able to select between using an existing payment option or adding a new one at checkout. In the current system, users can only add payment options during the checkout process.
In order to delete a payment option, users have to contact an Upside Navigator (Upside’s personal customer service team) who then create an internal ticket for the data team to approve. The goal of this feature was to reduce the time from 24 hours to 24 seconds, therefore reducing frustrations and improving the overall booking experience for the user.
Challenge
The challenge of this feature was working within the technical constraints of the project. Upside operates on the agile software development approach, therefore the scope of the project would be limited to one sprint. Because of this, it was important to understand the user needs to make sure the main pain points were addressed through the feature. Additionally, I had to work within the existing design guidelines.
The Market
I did competitive research to establish the baseline features ecommerce shops and travel sites used to help users view and manage their payment options.
After exploring multiple online vendors, I established that across all platforms users were able to
- view existing payment options under profile ‘Payment Information’
- delete, add and edit payment options under a ‘Payment Information’ tab in their profile
- add new payment option or use existing payment methods at checkout
- set a default payment option
The features that were common but were not consistently used
- ability to add a payment nickname
- edit payment options at checkout
- delete payment options at checkout
- see expired payment options at checkout
Stakeholder Interviews
Multiple rounds of stakeholder interviews were conducted throughout the design process to understand customer needs as well as engineering and security constraints associated with the project.
Quality and Training Team
This feature suggestion originated from the quality and training team, who work with the 24/7 customer service team, the navigators. The quality and training team was able to provide insight on the current system of managing payment options as well as insights on customer pain points. In the current system, Upside customers would have to contact a navigator to delete a card off their profile. The navigators would create a ticket for customer service who would then notify the data team. Speaking with the quality and training team the main pain point customers were experiencing was the inability to view all their payment options and the ability to delete payment options.
Engineering
Working within the agile development approach, meeting with the engineering team early was critical in ensuring that the designs I had produced would get built. After the meeting, features that were initially considered baseline became out of scope because of technical constraints. The technical constraints were tied to Upside’s payment data storage provider, BrainTree, and the constraints that exist within it.
Design
Being an intern it’s important to consult with other designers to ensure that my designs followed the brand guidelines. Throughout the design process I met with multiple senior designers and participated in design critiques to ensure that my designs were consistent with the product.
Digital Prototypes
User Testing
The feature was tested on ten Upside travelers recruited through a Qualaroo survey provided at checkout. Users were able to seamlessly find the ‘Payment Info’ tab and add and delete payment options under their account features. Users also seamlessly navigated between adding new payment options and using existing payment options at checkout.
Multiple users vocalized feature changes that were considered in the original designs but had to be removed due to technical constraints. These include being able to edit at checkout and adding a card nickname to be better able to distinguish between credit cards on file. These suggestions were noted will be incorporated into future designs.
Takeaways
My key takeaway from this project is to do stakeholder interviews early in the design process. Especially as an intern it’s important to understand the constraints and receive insights from stakeholders that will better guide the design process. Being an intern allowed me to bring fresh thoughts to the conversation, but also ensured I had to do a bit of catch up to fill knowledge gaps. For example, features that I initially thought were must haves after completing competitive research were no longer in the scope after meeting with the engineering and security team due to program constraints. Additionally it’s important to design with future features in mind. As Upside begins to take on greater corporate users, it was important that my designs could be iterated on to accommodate the changes that it brought.


Information on Dwolla Direct and the Off-site Gateway can be found at https://developers.dwolla.com/dev/docs/gateway/direct.html.


UKCloud Limited (“UKC”) and Virtual Infrastructure Group Limited (“VIG”) (together “the Companies”) – in Compulsory Liquidation
On 25 October 2022, the Companies were placed into Liquidation with the Official Receiver appointed as Liquidator and J Robinson and A M Hudson simultaneously appointed as Special Managers to manage the liquidation process on behalf of the Official Receiver.
Further information regarding the Liquidations can be found here: https://www.gov.uk/government/news/virtual-infrastructure-group-limited-and-ukcloud-limited-information-for-creditors-and-interested-parties
Contact details:
For any general queries relating to the Liquidations please email<EMAIL_ADDRESS>For customer related queries please email<EMAIL_ADDRESS>For supplier related queries please email<EMAIL_ADDRESS>Data Transfer - Region to Region Service Scope
About this document
This document describes the boundaries of the UKCloud Data Transfer – Region to Region service, along with the division of responsibilities between UKCloud and the customer, to facilitate the provisioning and ongoing use of the service.
About Data Transfer - Region to Region
The Data Transfer – Region to Region service enables customers to move their UKCloud for VMware workloads between regions on the UKCloud platform. To complete this task as efficiently as possible, we utilise the Zerto recovery tool as it's already implemented and tested on the platform for data migration and restoration.
Note
This service is specifically designed for UKCloud for VMware workloads that are Zerto-enabled.
Application process
Customers wanting to transfer UKCloud for VMware workloads between regions on the UKCloud platform will need to raise a service request for the Zerto tool to be implemented in their environment. To commence the service, raise a Service Request within the My Calls section of the UKCloud Portal.
Implementation
To transfer UKCloud for VMware workloads between regions, customers must use the Zerto recovery tool, which will be provisioned and set up for their use to transfer the workloads. This tool is made available free of charge for 10 working days for the migration only. Zerto is also available for UKCloud for VMware workloads for Journaling Protection at additional cost – which is outside of the functionality provided for this specific Data Transfer - Region to Region service.
Important
While the data transfer service is free of charge for 10 working days, customers will be charged for all compute and storage resources that are consumed in both the source and target regions. It is the customer's responsibility to ensure that the compute and storage in the source region is deleted once the transfer is complete in order to avoid unnecessary charges.
Service architecture
UKCloud will provide access to the Zerto recovery tool for the transfer of data between regions. Currently, Zerto is only enabled for UKCloud for VMware and will be provisioned for the purpose of transfer only between specific regions. Note that there is no functionality to transfer to region 1 or region 2. Workloads can only be transferred to regions 5,6,7 and 8. Also note that this is dependent on the security domain of the source region as this service can only be used to transfer workloads between:
Assured to Assured region
Elevated to Elevated region
If you need to transfer workloads between security domains (Assured and Elevated), then you'll need to use the Data Transfer between Assured and Elevated service.
The actual Zerto transfer service will be provided without charge for the transfer of workloads, with the following restrictions:
The service is free of charge for the first 10 working days. After 10 working days, the service will be charged as per the standard Journaling Protection costs in the UKCloud Pricing Guide.
Customers are required to inform UKCloud via a service request to confirm that the transfer is complete. The service will then be stopped, which will prevent further billing.
There is no Service Level Agreement for this service.
Customers utilising this service will not qualify for Service Credits due to unavailability or loss of performance during the transfer.
Once the Zerto tool has been provisioned, customers are responsible for the selection of VMs and data, and the actual transfer. If required, UKCloud can provide assistance via our Professional Services team, which can be arranged via your Service Delivery Manager.
The How to migrate your workloads between UKCloud regions article on the Knowledge Centre provides all the information you'll require to understand the tool as well as configuration details and step-by-step instructions.
Service availability
As a free service for data transfer between regions, customers are not entitled to Service Credits for any downtime during data transfer scenarios.
Supporting documents and resources
The following documents contain more information about the Zerto and the service options:
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


The following is a list of compile dependencies for this project. These dependencies are required to compile and run the application:
| GroupId | ArtifactId | Version | Type | Licenses |
|---|---|---|---|---|
| io.oasp.java.modules | oasp4j-jpa-dao | 3.0.0 | jar | Apache Software Licenese |
| org.slf4j | slf4j-api | 1.7.25 | jar | MIT License |
The following is a list of transitive dependencies for this project. Transitive dependencies are the dependencies of the project dependencies.
The following is a list of compile dependencies for this project. These dependencies are required to compile and run the application:
Eclipse Distribution License (EDL), Version 1.0: Java Persistence API, Version 2.1
Eclipse Public License (EPL), Version 1.0: Java Persistence API, Version 2.1
Apache Software Licenese: mmm-util-core, mmm-util-entity, mmm-util-pojo, mmm-util-search, oasp4j-basic, oasp4j-jpa, oasp4j-jpa-basic, oasp4j-jpa-dao
BSD: ASM Core
MIT License: Bridge method injection annotations, SLF4J API Module
Apache License, Version 2.0: Querydsl - Core module, Querydsl - JPA support, Spring Beans, Spring Commons Logging Bridge, Spring Core, Spring Data Core
ASF 2.0: cglib
CDDL + GPLv2 with classpath exception: javax.transaction API
The Apache Software License, Version 2.0: Apache Ant Core, Apache Ant Launcher, FindBugs-jsr305, Guava: Google Core Libraries for Java, javax.inject, lang
| Filename | Size | Entries | Classes | Packages | Java Version | Debug Information |
|---|---|---|---|---|---|---|
| cglib-3.2.5.jar | 302 kB | 267 | 246 | 8 | 1.5 | Yes |
| jsr305-1.3.9.jar | 33 kB | 72 | 35 | 3 | 1.5 | Yes |
| guava-17.0.jar | 2.2 MB | 1715 | 1686 | 17 | 1.6 | Yes |
| bridge-method-annotation-1.13.jar | 3.2 kB | 13 | 2 | 1 | 1.5 | No |
| mysema-commons-lang-0.2.4.jar | 12.1 kB | 18 | 7 | 1 | 1.6 | Yes |
| querydsl-core-4.1.4.jar | 458.5 kB | 364 | 346 | 9 | 1.6 | Yes |
| querydsl-jpa-4.1.4.jar | 126.2 kB | 85 | 70 | 6 | 1.6 | Yes |
| basic/target/classes | - | 0 | 0 | 0 | - | No |
| jpa-basic/target/classes | - | 0 | 0 | 0 | - | No |
| jpa-dao/target/classes | - | 0 | 0 | 0 | - | No |
| javax.inject-1.jar | 2.5 kB | 8 | 6 | 1 | 1.5 | No |
| javax.transaction-api-1.2.jar | 30.7 kB | 35 | 22 | 2 | 1.7 | Yes |
| mmm-util-core-7.5.1.jar | 831.2 kB | 862 | 741 | 76 | 1.7 | Yes |
| mmm-util-entity-7.5.1.jar | 29.1 kB | 49 | 28 | 6 | 1.7 | Yes |
| mmm-util-pojo-7.5.1.jar | 220.1 kB | 220 | 186 | 19 | 1.7 | Yes |
| mmm-util-search-7.5.1.jar | 8.2 kB | 21 | 7 | 3 | 1.7 | Yes |
| ant-1.9.6.jar | 2 MB | 1227 | 1146 | 61 | 1.5 | Yes |
| ant-launcher-1.9.6.jar | 18.4 kB | 14 | 5 | 1 | 1.5 | Yes |
| hibernate-jpa-2.1-api-1.0.2.Final.jar | 113.4 kB | 207 | 200 | 4 | 1.6 | Yes |
| asm-5.2.jar | 53.3 kB | 31 | 26 | 2 | 1.2 | No |
| slf4j-api-1.7.25.jar | 41.2 kB | 46 | 34 | 4 | 1.5 | Yes |
| spring-beans-5.0.8.RELEASE.jar | 660.4 kB | 406 | 376 | 13 | 1.8 | Yes |
| spring-core-5.0.8.RELEASE.jar | 1.2 MB | 894 | 842 | 44 | 1.8 | Yes |
| spring-jcl-5.0.8.RELEASE.jar | 21.7 kB | 24 | 15 | 2 | 1.8 | Yes |
| spring-data-commons-2.0.9.RELEASE.jar | 1.1 MB | 776 | 709 | 40 | 1.8 | Yes |
| Total | Size | Entries | Classes | Packages | Java Version | Debug Information |
| 25 | 9.5 MB | 7354 | 6735 | 323 | 1.8 | 19 |
| compile: 25 | compile: 9.5 MB | compile: 7354 | compile: 6735 | compile: 323 | - | compile: 19 |


{{'Details' | wlNgWLocale:lang}}
{{'Feels like' | wlNgWLocale:lang}}
{{weather.current.temperatureApparent | wlNgWTemp:mu.temperature}}°
{{'Max' | wlNgWLocale:lang}}
{{weather.today.temperatureMax | wlNgWTemp:mu.temperature}}°
{{'Min' | wlNgWLocale:lang}}
{{weather.today.temperatureMin | wlNgWTemp:mu.temperature}}°
{{'Humidity' | wlNgWLocale:lang}}
{{weather.current.humidity}} %
{{'Today' | wlNgWLocale:lang}}: {{weather.today.description}}
{{'Tomorrow' | wlNgWLocale:lang}}: {{weather.tomorrow.description}}


<p> This is line </p>
Assignments
1. Profile 2. Show HTML code on Webpage (Teach HTML to others )
We learned today:


Base class for array-like structures. More...
#include <ArrayBase.h>
Public Types | |
| typedef T | type |
Public Member Functions | |
| ArrayBase (void) | |
| ArrayBase (size_t maxSize) | |
| ArrayBase (size_t maxSize, T fill) | |
| ~ArrayBase (void) | |
| size_t | size (void) |
| T | get (size_t index) const |
| void | set (size_t index, T contents) |
| int | find (T element) |
| int | find (T element, size_t startIndex) |
| void | fill (T contents) |
| void | clear () |
| virtual bool | isEmpty () |
| bool | operator== (const ArrayBase< T > &rhs) const |
| bool | operator!= (const ArrayBase< T > &rhs) const |
| T | operator[] (size_t index) const |
| T & | operator[] (size_t index) |
Base class for array-like structures.
Contains the actual raw array of type T along with common properties and methods for array like structures.
| T | (typename) Element type of array. |
Definition at line 22 of file ArrayBase.h.
Definition at line 46 of file ArrayBase.h.
Default initializing constructor.
Creates the raw array of type T
and sets the maximum size to 10 by default.
Definition at line 17 of file ArrayBase.cpp.
Initializing constructor. Sets max size to maxSize
, effectively overriding the default.
| maxSize | (size_t) Maximum size of the array. |
Definition at line 26 of file ArrayBase.cpp.
Initializing constructor. Sets max size to maxSize
and filling each element of the array with fill
.
| maxSize | (size_t) Maximum size of the array. |
| fill | (T) Contents of each element. |
Definition at line 44 of file ArrayBase.cpp.
| void ArrayBase< T >::clear | ( | ) |
Clears all elements from the array.
| void ArrayBase< T >::fill | ( | T | contents | ) |
Set each element in raw array to given element
up to the maximum size.
| contents | (T) Element to fill ArrayBase with. |
Definition at line 158 of file ArrayBase.cpp.
| int ArrayBase< T >::find | ( | T | element | ) |
Return first index
that matches element.
| element | (T) Element to match with. |
index
or -1 if no match. Definition at line 115 of file ArrayBase.cpp.
| int ArrayBase< T >::find | ( | T | element, |
| size_t | startIndex | ||
| ) |
Return first index
that matches element
starting at the given index.
| element | (T) Element to match with. |
| startIndex | (size_t) The index to start with. |
index
or -1 if no match. Definition at line 124 of file ArrayBase.cpp.
| T ArrayBase< T >::get | ( | size_t | index | ) | const |
Query the element at specified index.
| index | (size_t) Index of query element. |
| std::out_of_range | Index is out of the range. |
Definition at line 76 of file ArrayBase.cpp.
|
virtual |
Test to see if array is empty.
Determine inequality with given ArrayBase.
Definition at line 197 of file ArrayBase.cpp.
Determine equality with given ArrayBase.
Definition at line 172 of file ArrayBase.cpp.
| T ArrayBase< T >::operator[] | ( | size_t | index | ) | const |
Query the element given the index.
| index | (size_t) Index of the element. |
index
. Definition at line 220 of file ArrayBase.cpp.
| T & ArrayBase< T >::operator[] | ( | size_t | index | ) |
Query the element given the index.
| index | (size_t) Index of the element. |
index
. Definition at line 210 of file ArrayBase.cpp.
| void ArrayBase< T >::set | ( | size_t | index, |
| T | contents | ||
| ) |
Sets the element at the specified index.
| index | (size_t) Index of element. |
| contents | (T) Contents of element. |
| std::out_of_range | Index is out of the range. |
Definition at line 93 of file ArrayBase.cpp.
| size_t ArrayBase< T >::size | ( | void | ) |
Query the current size.


Tres - Step 2
As we make the leap to F#, we're changing things around significantly. Remember our
discussion about the flat structure of an F# project? Instead of an Domain
directory with a lot
of little files, we'll define a single Domain.fs
file in the root of the project. Don't forget to add it to the list
of compiled files in Tres.fsproj
; it should go above HomeModule.fs
.
Next up, we will change the static classes that we created to eliminate magic strings into modules. The
AuthorizationLevel
type in C# looked like:
1: 2: 3: 4: 5: 6: |
|
The F# version (within the namespace Tres.Entities
):
1: 2: 3: 4: 5: 6: |
|
The RequireQualifiedAccess
attribute means that this module cannot be open
ed, which means that Administrator
cannot ever be construed to be that value; it must be referenced as AuthorizationLevel.Administrator
. The
Literal
attribute means that these values can be used in places where a literal string is required. (There is a
specific place this will help us when we start writing code around these types.) Also of note here is the different
way F# defines attributes from the way C# does; instead of [
]
pairs, we use [<
>]
pairs.
We are also going to change from class types to record types. Record types can be thought of as struct
s, though the
comparison is not exact; record types are reference types, not value types, but they cannot be set to null in code
(huge caveat which we'll see in the next step) unless explicitly identified. We're also going to embrace F#'s
immutability-by-default qualities that will save us a heap of null checks (as well as those pesky situations where we
forget to implement them).
As a representative example, consider the Page
type. In C#, it looks like this:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: |
|
It contains strings, for the most part, and a Revisions
collection. Now, here's how we'll implement this same thing
in F#:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: |
|
The field declarations immediately under the type
declaration mirror those in our C# version; since they are fields,
though, we don't have to define getters and setters.
F# requires record types to always have all fields defined. F# also provides a with
statement (separate from the one
in the code above) that allows us to create a new instance of a record type that has all the fields of our original
ones, only replacing the ones we specify. So, in C#, while we can do something like...
1:
|
|
...leaving all the other fields in their otherwise-initialized state, F# will not allow us to do that. This is where
the Empty
static property comes in; we can use this to create new pages, while ensuring that we have sensible
defaults for all the other fields. The equivalent to the above C# statement in F# would be
1:
|
|
. Note the default values for Permalink
: in C#, it's null, but in F#, it's an empty string. Now, certainly, you can
use String.IsNullOrEmpty()
to check for both of those, but we'll see some advantages to this lack of nullability as
we continue to develop this project.
A few syntax notes:
-
The
CLIMutable
attribute instructs the compiler to generate a no-argument constructor for the underlying class. It is not something we will reference in our code, but when RavenDB tries to create instances of these types when we load them from the database, this will help it. -
The
NoComparison
andNoEquality
attributes make these classes more lightweight. By default, F# will generate a custom equality operation for each record type that compares every field within the record; with these attributes, it will leave that code out. This is fine for our purposes; we aren't going to be comparing pages with=
or>
. -
[]
represents an empty list in F#. An F# list (as distinguished fromSystem.Collections.List
orSystem.Collections.Generic.List<T>
) is also an immutable data structure; it consists of a head element, and a tail list. It can be constructed by creating a new list with an element as its head and the existing list as its tail, and deconstructed by processing the head, then processing the head of the tail, etc. (There are operators and functions to support that; we'll definitely use those as we go along.) Items in a list are separated by semicolons;[ "one"; "two"; "three" ]
represents astring list
with three items. It supports most all the collection operations you would expect, but there are some differences. - While not demonstrated here, arrays are defined between
[|
|]
pairs, also with elements separated by semicolons.
Before continuing on to Quatro / Cinco, you should familiarize yourself with the types in this step.
val string : value:'T -> string
--------------------
type string = System.String
type HtmlArticleContent =
interface IArticleContent
new : unit -> HtmlArticleContent
--------------------
new : unit -> HtmlArticleContent
interface
abstract member Generate : unit -> string
abstract member ContentType : string
abstract member Text : string
abstract member Text : string with set
end
type CLIMutableAttribute =
inherit Attribute
new : unit -> CLIMutableAttribute
--------------------
new : unit -> CLIMutableAttribute
type NoComparisonAttribute =
inherit Attribute
new : unit -> NoComparisonAttribute
--------------------
new : unit -> NoComparisonAttribute
type NoEqualityAttribute =
inherit Attribute
new : unit -> NoEqualityAttribute
--------------------
new : unit -> NoEqualityAttribute
val int64 : value:'T -> int64 (requires member op_Explicit)
--------------------
type int64 = System.Int64
--------------------
type int64<'Measure> = int64
type RequireQualifiedAccessAttribute =
inherit Attribute
new : unit -> RequireQualifiedAccessAttribute
--------------------
new : unit -> RequireQualifiedAccessAttribute
from Tres.Domain
type LiteralAttribute =
inherit Attribute
new : unit -> LiteralAttribute
--------------------
new : unit -> LiteralAttribute
{AsOf: int64;
Text: IArticleContent;}
static member Empty : Revision
from Tres.Domain
{Id: string;
WebLogId: string;
AuthorId: string;
Title: string;
Permalink: string;
PublishedOn: int64;
UpdatedOn: int64;
ShowInPageList: bool;
Text: IArticleContent;
Revisions: Revision list;}
static member Empty : Page