char * mrutils::GuiEditBox::editText(const char * text) {
if (!init_) init();
if (frozen) thaw();
if (termLine.nextLine(text)) return termLine.line;
else return NULL;
}
void DefaultPVArray<string>::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pcontrol) {
size_t size = this->getArray()->getArraySizeType() == Array::fixed ?
this->getArray()->getMaximumCapacity() :
SerializeHelper::readSize(pbuffer, pcontrol);
svector nextvalue(thaw(value));
// Decide if we must re-allocate
if(size > nextvalue.size() || !nextvalue.unique())
nextvalue.resize(size);
else if(size < nextvalue.size())
nextvalue.slice(0, size);
string * pvalue = nextvalue.data();
for(size_t i = 0; i<size; i++) {
pvalue[i] = SerializeHelper::deserializeString(pbuffer,
pcontrol);
}
value = freeze(nextvalue);
// inform about the change?
postPut();
}
/**
* It run and then freeze.
*/
int run_then_freeze() {
if (isfrozen()) {
// true means that next time threads are frozen again
thaw(true);
return 0;
}
if (!prepared) if (prepare()<0) return -1;
freeze();
return run();
}
/// Run and then freeze.
int run_then_freeze() {
if (isfrozen()) {
thaw();
freeze();
return 0;
}
if (!prepared) if (prepare()<0) return -1;
freeze();
return run();
}
void PVUnionArray::setCapacity(size_t capacity)
{
if(this->isCapacityMutable()) {
checkLength(capacity);
const_svector value;
swap(value);
if(value.capacity()<capacity) {
svector mvalue(thaw(value));
mvalue.reserve(capacity);
value = freeze(mvalue);
}
swap(value);
}
else
THROW_EXCEPTION2(std::logic_error, "capacity immutable");
}
/**
* \brief Waits for thread termination
*
* It defines the wait for thread termination.
*
* \return 0 if successful.
*/
int wait() {
stp=true;
if (isfrozen()) {
wait_freezing();
thaw();
}
if (spawned) {
pthread_join(th_handle, NULL);
if (barrier) barrier->decCounter();
}
if (pthread_attr_destroy(&attr)) {
error("ERROR: ff_thread.wait: pthread_attr_destroy fails!");
}
spawned=false;
return 0;
}
void DefaultPVArray<T>::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pcontrol) {
size_t size = this->getArray()->getArraySizeType() == Array::fixed ?
this->getArray()->getMaximumCapacity() :
SerializeHelper::readSize(pbuffer, pcontrol);
svector nextvalue(thaw(value));
nextvalue.resize(size); // TODO: avoid copy of stuff we will then overwrite
T* cur = nextvalue.data();
// try to avoid deserializing from the buffer
// this is only possible if we do not need to do endian-swapping
if (!pbuffer->reverse<T>())
if (pcontrol->directDeserialize(pbuffer, (char*)cur, size, sizeof(T)))
{
// inform about the change?
PVField::postPut();
return;
}
// retrieve value from the buffer
size_t remaining = size;
while(remaining) {
const size_t have_bytes = pbuffer->getRemaining();
// correctly rounds down in an element is partially received
const size_t available = have_bytes/sizeof(T);
if(available == 0) {
// get at least one element
pcontrol->ensureData(sizeof(T));
continue;
}
const size_t n2read = std::min(remaining, available);
pbuffer->getArray(cur, n2read);
cur += n2read;
remaining -= n2read;
}
value = freeze(nextvalue);
// TODO !!!
// inform about the change?
PVField::postPut();
}
void Creep::setOnFire(float burnTime)
{
m_burnTime = burnTime;
if (FlagUtil::isFlagSet(m_creepCondition, FROZEN))
{
thaw();
}
if (!FlagUtil::isFlagSet(m_creepCondition, ON_FIRE))
{
m_creepCondition = FlagUtil::setFlag(m_creepCondition, ON_FIRE);
m_fRed = 0.25f;
m_fGreen = 0.25f;
m_fBlue = 0.25f;
}
}
void PVUnionArray::setLength(size_t length)
{
if(this->isImmutable())
THROW_EXCEPTION2(std::logic_error, "immutable");
const_svector value;
swap(value);
if (length == value.size())
return;
checkLength(length);
if (length < value.size()) {
value.slice(0, length);
} else {
svector mvalue(thaw(value));
mvalue.resize(length);
value = freeze(mvalue);
}
swap(value);
}
virtual int wait() {
int r=0;
stp=true;
if (isfrozen()) {
wait_freezing();
thaw();
}
if (spawned) {
pthread_join(th_handle, NULL);
if (barrier) barrier->decCounter();
}
if (attr) {
if (pthread_attr_destroy(attr)) {
error("ERROR: ff_thread.wait: pthread_attr_destroy fails!");
r=-1;
}
free(attr);
attr = NULL;
}
spawned=false;
return r;
}
int
main(int argc, char* argv[])
{
struct hv_vss_opt_msg userdata;
struct pollfd hv_vss_poll_fd[1];
uint32_t op;
int ch, r, len, error;
int hv_vss_dev_fd;
int freeze_thaw = UNDEF_FREEZE_THAW;
while ((ch = getopt(argc, argv, "dnh")) != -1) {
switch (ch) {
case 'n':
/* Run as regular process for debugging purpose. */
is_daemon = 0;
break;
case 'd':
/* Generate debugging output */
is_debugging = 1;
break;
case 'h':
default:
usage(argv[0]);
break;
}
}
openlog("HV_VSS", 0, LOG_USER);
/* Become daemon first. */
if (is_daemon == 1)
daemon(1, 0);
else
VSS_LOG(LOG_DEBUG, "Run as regular process.\n");
VSS_LOG(LOG_INFO, "HV_VSS starting; pid is: %d\n", getpid());
memset(&userdata, 0, sizeof(struct hv_vss_opt_msg));
/* register the daemon */
hv_vss_dev_fd = open(VSS_DEV(FS_VSS_DEV_NAME), O_RDWR);
if (hv_vss_dev_fd < 0) {
VSS_LOG(LOG_ERR, "Fail to open %s, error: %d %s\n",
VSS_DEV(FS_VSS_DEV_NAME), errno, strerror(errno));
exit(EXIT_FAILURE);
}
hv_vss_poll_fd[0].fd = hv_vss_dev_fd;
hv_vss_poll_fd[0].events = POLLIN | POLLRDNORM;
while (1) {
r = poll(hv_vss_poll_fd, 1, INFTIM);
VSS_LOG(LOG_DEBUG, "poll returned r = %d, revent = 0x%x\n",
r, hv_vss_poll_fd[0].revents);
if (r == 0 || (r < 0 && errno == EAGAIN) ||
(r < 0 && errno == EINTR)) {
/* Nothing to read */
continue;
}
if (r < 0) {
/*
* For poll return failure other than EAGAIN,
* we want to exit.
*/
VSS_LOG(LOG_ERR, "Poll failed.\n");
perror("poll");
exit(EIO);
}
/* Read from character device */
error = ioctl(hv_vss_dev_fd, IOCHVVSSREAD, &userdata);
if (error < 0) {
VSS_LOG(LOG_ERR, "Read failed.\n");
perror("pread");
exit(EIO);
}
if (userdata.status != 0) {
VSS_LOG(LOG_ERR, "data read error\n");
continue;
}
/*
* We will use the KVP header information to pass back
* the error from this daemon. So, first save the op
* and pool info to local variables.
*/
op = userdata.opt;
switch (op) {
case HV_VSS_CHECK:
error = check();
break;
case HV_VSS_FREEZE:
error = freeze();
break;
case HV_VSS_THAW:
error = thaw();
break;
default:
VSS_LOG(LOG_ERR, "Illegal operation: %d\n", op);
error = VSS_FAIL;
}
if (error)
userdata.status = VSS_FAIL;
else
userdata.status = VSS_SUCCESS;
error = ioctl(hv_vss_dev_fd, IOCHVVSSWRITE, &userdata);
if (error != 0) {
VSS_LOG(LOG_ERR, "Fail to write to device\n");
exit(EXIT_FAILURE);
} else {
VSS_LOG(LOG_INFO, "Send response %d for %s to kernel\n",
userdata.status, op == HV_VSS_FREEZE ? "Freeze" :
(op == HV_VSS_THAW ? "Thaw" : "Check"));
}
}
}
void Creep::update(float deltaTime)
{
m_fStateTime += deltaTime;
m_healthBarFrame = m_health * 16 / m_maxHealth - 1;
m_healthBarFrame = m_healthBarFrame < 0 ? 0 : m_healthBarFrame;
m_timeToShowHealthBar -= deltaTime;
if (FlagUtil::isFlagSet(m_creepCondition, ELECTRIFIED))
{
if (m_electrifiedTime > 0)
{
m_electrifiedTime -= deltaTime;
}
else
{
m_creepCondition = FlagUtil::removeFlag(m_creepCondition, ELECTRIFIED);
m_speed = m_initialSpeed;
if (FlagUtil::isFlagSet(m_creepCondition, FROZEN))
{
m_speed /= 3;
}
}
}
if (FlagUtil::isFlagSet(m_creepCondition, POISONED))
{
if (m_poisonedTime > 0)
{
bool isFrozen = FlagUtil::isFlagSet(m_creepCondition, FROZEN);
m_poisonedTime -= deltaTime;
m_poisonTime += deltaTime;
while (m_poisonTime > TIME_FOR_POISON_DAMAGE)
{
m_poisonTime -= TIME_FOR_POISON_DAMAGE;
takeDamage(m_poisonDamage, Damage_Type::ACID);
}
if (m_isGrowingDueToPoison)
{
m_fWidth += deltaTime * (isFrozen ? 0.1f : 0.5f);
m_fHeight += deltaTime * (isFrozen ? 0.1f : 0.5f);
if (m_fWidth > m_maxSize)
{
m_fWidth = m_maxSize;
m_fHeight = m_maxSize;
m_isGrowingDueToPoison = false;
}
}
else
{
m_fWidth -= deltaTime * (isFrozen ? 0.1f : 0.5f);
m_fHeight -= deltaTime * (isFrozen ? 0.1f : 0.5f);
if (m_fWidth < m_halfSize)
{
m_fWidth = m_halfSize;
m_fHeight = m_halfSize;
m_isGrowingDueToPoison = true;
}
}
}
else
{
m_creepCondition = FlagUtil::removeFlag(m_creepCondition, POISONED);
m_fWidth = m_defaultSize;
m_fHeight = m_defaultSize;
}
resetBounds(m_fWidth * SIZE_TO_BOUNDS_RATIO, m_fHeight * SIZE_TO_BOUNDS_RATIO);
}
if (FlagUtil::isFlagSet(m_creepCondition, FROZEN))
{
if (m_frozenTime > 0)
{
m_frozenTime -= deltaTime;
m_fRed += m_frozenRecoveryRate * deltaTime;
m_fGreen = m_fRed;
}
else
{
thaw();
}
}
else if (FlagUtil::isFlagSet(m_creepCondition, ON_FIRE))
{
if (m_burnTime > 0)
{
m_burnTime -= deltaTime;
}
else
{
m_creepCondition = FlagUtil::removeFlag(m_creepCondition, ON_FIRE);
m_creepCondition = FlagUtil::setFlag(m_creepCondition, FIRE_RECOVERY);
}
}
else if (FlagUtil::isFlagSet(m_creepCondition, FIRE_RECOVERY))
{
m_fRed += 1.5f * deltaTime;
m_fGreen = m_fRed;
m_fBlue = m_fRed;
if (m_fRed > 1)
{
m_creepCondition = FlagUtil::removeFlag(m_creepCondition, FIRE_RECOVERY);
resetColor();
}
}
m_deltaX = m_velocity->getX() * deltaTime;
m_deltaY = m_velocity->getY() * deltaTime;
m_position->add(m_deltaX, m_deltaY);
m_direction = calcDirection();
updateBounds();
}
